Adjudicate America: How Article III Turns a Conflict into an Enforceable Judgment

Starting question

How can a system accept a concrete conflict, prove its own authority to hear it, separate established facts from the parties’ assertions, select the law in force, enter a bounded judgment, and restore the affected domain to an admissible state?

The complete research foundation for this public adaptation is available on Zenodo: Code Constitution.

A red line appears on the map

Connected America in Death Stranding creates the reassuring sense of shared infrastructure. Roads join, other people’s bridges become part of our route, stations accept one protocol, and the map gradually stops looking like a collection of isolated patches. The fourth publication reproduced precisely this state: Article IV turned the states into autonomous nodes of a common federal network and defined how acts, records, judicial judgments, citizens, and obligations cross internal borders.

A common network immediately creates a new class of events. Two nodes may recognize the existence of the same artifact and still dispute its effect. A receiving state may obtain an authentic judgment and demand an enforcement measure that the judgment never possessed in the originating jurisdiction. A citizen may encounter different conditions and claim that the distinction violates a protected standing. A federal rule may claim supremacy while a local rule invokes its own subject-matter competence. Connectivity makes conflict observable and portable.

In the previous build, such events entered the requires-resolution state, suspended a dangerous operation, and were handed off to article-iii:resolve. This was Article IV’s deliberate limit. A federal protocol can verify a packet’s provenance, integrity, revision, competence, and requested effect. A legally contested result requires another authority, another procedure, and another bearer of responsibility.

Article III establishes that circuit. It creates the judicial power, enumerates its domains, distributes original and appellate jurisdiction, guarantees jury trial and the location of criminal trials, and defines treason and its proof requirements with exceptional narrowness. Later doctrine adds case-or-controversy requirements, judicial review, standing, ripeness, mootness, the prohibition on advisory opinions, and rules governing finality.

The fifth build accepts a conflict from Article IV and, for the first time, produces an object capable of proceeding to material execution. It also sets an automation boundary: the program checks record provenance, links between facts and conclusions, the hierarchy of authority, remedy scope, and review lineage. The substance of evidence, the applicability of law, and the legal conclusion arrive through an attributed human decision. The judicial machine gains tracing discipline while human beings remain responsible for meaning.

The fifth build

The reverse assembly of the Constitution has reached resolve():

The fifth function receives state created by every preceding layer. The judiciary is bound to the current constitutional root from Article V and the federal topology from Article IV. It accepts only enumerated classes of cases and controversies. Every court has its own proved mandate. Every judgment cites a closed record and operative authorities. Every remedy receives a bounded scope and a separate executor.

Seven principal operations appear in the code:

For the first time, this architecture forces us to distinguish four similar events. A WARDEN failure detects a breached invariant. A judicial finding establishes a fact from the record. A holding connects an established fact to applicable law. A remedy defines how a particular domain will be restored. Combining all four in one omnipotent component would make the system shorter and more dangerous; tyranny often has excellent DX until the user notices that the role of user has already been abolished.

Judicial power as a separate circuit

Section 1 of Article III vests the judicial power in one Supreme Court and in inferior courts that Congress establishes. Judges of both the supreme and inferior courts hold office during good Behaviour and receive compensation that cannot be diminished while they remain in office. These provisions create institutional independence for a decision from the current wishes of the party controlling the budget or execution.

The software model translates them into topological invariants. Exactly one component in the system has type supreme. An inferior Article III court requires a verified legislative foundation. Every active court has at least one judge with an authenticated commission, good-behaviour tenure, and non-diminution compensation protection. Annual renewal of authority, or budgetary power to reduce pay in response to a decision, blocks construction of the judicial circuit itself.

This code does not claim that an American judge is an object with three fields. It identifies properties without which an independent resolver gradually becomes a method of the calling component. The executive gains a convenient court, the legislature gains an obedient interpreter, and the system gains a verification ceremony in place of a separate power.

Judicial appointments connect to Article II, while the establishment of inferior courts and their statutory jurisdiction connect to Article I. The cycle’s reverse order temporarily requires constituteJudiciary() to receive already authenticated commissions and statutory grants. The next publications will explain their provenance and replace test fixtures with full outputs from execute() and legislate().

WARDEN remains an external testing circuit. It can confirm the existence of one Supreme Court, tenure protection, record integrity, and remedy boundaries. A court possesses authority to establish legally relevant facts and decide a concrete dispute. The separation remains even when both operations happen to be expressed as JavaScript functions.

A dispute begins with the right to be heard

Article III’s judicial power extends to enumerated Cases and Controversies. Modern doctrine develops requirements of concreteness from that formula. A federal court hears an adversarial dispute in which a claimant shows injury in fact, causation, and the capacity of a judicial decision to redress that injury. The dispute reaches the court at the proper time and remains live. An abstract question about the correct reading of the Constitution remains outside such adjudication.

The prototype expresses this threshold through six checks:

Each value represents the result of a previously authenticated legal and factual assessment. A Boolean field does not reveal a philosophical truth about injury and causation. It makes the provenance of admissibility observable to the next operation. A real system would require separate artifacts, objections, hearings, and decisions on threshold issues.

The absence of any element produces dismissed-without-merits. That result has independent significance. The court reports that this case failed the gate of judicial power while leaving the substance of the disputed rule open for another proper case. The software model therefore does not record a standing dismissal as confirmation that the defendant’s action was lawful.

A potential political question receives the separate state requires-justiciability-determination. WARDEN cannot turn that label into a final answer. A court must determine whether a manageable legal standard exists, whether the issue has been committed to another branch, and which part of the dispute can still be resolved judicially.

flowchart TD
    A["Клопотання"] --> B{"Справа або спір?"}
    B -->|"Ні"| C["Закриття без розгляду суті"]
    B -->|"Так"| D{"Юрисдикційна підстава"}
    D --> E["Компетентний суд"]
    E --> F["Доказовий запис"]
    F --> G["resolve()"]

Nine heads and one competent forum

Article III enumerates nine classes of federal judicial power. They can be represented as typed inputs, although each type carries an extensive doctrinal history:

The presence of a category sets the boundary of federal judicial power; it does not yet assign a particular court. The Constitution places cases affecting ambassadors, other public ministers and consuls, and those in which a state is a party within the Supreme Court’s original jurisdiction. The other enumerated cases fall within the Supreme Court’s appellate jurisdiction, subject to the exceptions and regulations Congress makes under the Constitution. Federal statutes create and distribute the actual jurisdiction of inferior courts. For example, 28 U.S.C. § 1251 makes controversies between states part of the Supreme Court’s original and exclusive jurisdiction.

The prototype stores grants in the court registry. docketCase() verifies the constitutional category, the chosen court’s proved original authority, and the special route for an interstate dispute. Receiving a petition does not enlarge a component’s competence. Nor does courtId: "supreme" transform an ordinary appellate question into a case of original jurisdiction.

The Eleventh Amendment requires a separate version-aware gate. Its text limits judicial power in specified suits against a state by citizens of another state or of a foreign state. The model blocks a direct suit of the specified class against a nonconsenting member state and permits explicitly authenticated consent through this narrow prototype gate. Modern doctrine on state immunity, waivers, congressional abrogation, and Ex parte Young is considerably more complex. The fifth build candidly marks this area as an abbreviated model.

flowchart TD
    A["Федеральний спір"] --> B{"Між штатами?"}
    B -->|"Так"| C["Первинна юрисдикція Верховного суду"]
    B -->|"Ні"| D["Нижчий суд із законним мандатом"]
    D --> E["Апеляційний перегляд"]
    C --> E

The record separates assertion from fact

The parties enter the proceeding with incompatible assertions. A judicial decision rests on facts established through the applicable procedure. Evidence, rules of admissibility, objections, stipulations, and the work of an authorized fact finder occupy the space between those states.

closeRecord() accepts evidence and findings. Every evidentiary object has an identifier, class, authentication state, admission state, and set of supported propositions. Every finding cites one or more admitted and authenticated evidence IDs. A reference to a missing object, excluded evidence, or an unauthenticated document blocks closure of the record.

The model intentionally does not calculate the truthfulness of testimony or the weight of evidence. The fact finder supplies the final finding under its own authenticated authority and accepts responsibility for the assessment. The code confirms that the later judgment uses that closed record and does not invent a new fact inside resolve().

This approach matters especially when working with an LLM. A language model can generate a persuasive intermediate explanation that never appeared in the case materials. Without mandatory links to a finding and evidence, such a phrase easily becomes an “established fact” simply because it looks good in the text. States mastered this magic long before transformers; automation merely promises industrial scale with a pleasant interface.

flowchart TD
    A["Допущені докази"] --> B["Встановлені факти"]
    C["Чинне право"] --> D["Правовий висновок"]
    B --> D
    D --> E["Засіб відновлення"]

resolve() produces an explainable judgment

The central function accepts a judiciary, docket, closed record, set of authorities, and a human-authored decision. It verifies the integrity of every input and creates an immutable judgment.

An authority has a type, citation, operative status, authenticated provenance, and place in the hierarchy. The Constitution and amendments must belong to the current root. A federal statute requires a separate pursuance determination, while a treaty requires confirmation that it was made under the Authority of the United States. State law may remain in the set as an actually existing source while also carrying displacedBy with a reference to the supreme rule that controls it.

A holding contains five required parts:

The prototype blocks a holding that cites a missing finding, an invented authority, or a displaced local rule without including the controlling supreme rule. This control represents judicial review as an operation within a concrete case. Article III’s text does not directly contain a developed judicial-review algorithm; the historical and doctrinal line firmly associated with Marbury v. Madison explains the court’s application of the Constitution when rules conflict.

The code does not select the legally “correct” interpretation by numeric rank. Rank protects an already established hierarchy of sources. Applicability, meaning, and scope remain the substance of a holding adopted by the court. Constitutional text, statutes, precedent, and facts can support several reasoned combinations. The decision gains a verifiable structure and still requires an accountable author.

In the demonstration case, a receiving state seeks to replace the original effect of a money judgment with imprisonment of the debtor. Article IV returns requires-resolution with reason effect-exceeds-or-differs-from-origin. The court establishes two facts: the originating judgment authorizes monetary recovery, while the receiving authority demands imprisonment. The holding applies Article IV, 28 U.S.C. § 1738, and the status of the conflicting local rule. The remedy confines enforcement to the effect available in the originating jurisdiction.

{
  status: "judgment-entered",
  disposition: "grant-relief",
  holdings: [
    {
      id: "holding:same-effect",
      authorityIds: [
        "authority:article-iv",
        "authority:28-usc-1738",
        "authority:hamilton-enforcement"
      ],
      findingIds: [
        "finding:origin-effect",
        "finding:requested-effect"
      ]
    }
  ],
  execution: "pending-separate-execution",
  handoff: "article-ii:execute"
}

Remedy ends where execution begins

A court may grant or deny relief, dismiss a case without reaching the merits, limit an operation, compel a prescribed action, vacate a challenged state, or remand for a new proceeding. The actual set of remedies depends on jurisdiction, cause of action, and applicable law. The prototype models a general restoration contract.

Every coercive remedy contains a target, operation, scope, executableBy, confirmation of redressability, and a check for the least sufficient scope. A remedy incapable of redressing the proved injury conflicts with the standing threshold. A remedy extending beyond the case adjudicated turns concrete judicial authority into general administrative power.

resolve() does not alter the federal runtime by itself. It returns pending-separate-execution and the address article-ii:execute. The court defines the required state; the executive circuit selects and applies authorized material means. The next publication will test whether the presidential control plane can faithfully execute a judgment, preserve its trace, restrict capability, and return confirmation of the result.

A denial of relief produces case-closed and no-coercive-remedy. This too is an executable state in the broad sense: the system knows that no coercive operation exists. The judicial component receives no invitation to “do something useful anyway” after denying relief. The impulse is very human, especially once the budget has been spent, but a capability model values boring precision.

Review creates lineage

An appeal operates on an existing judgment. It verifies an authenticated and timely notice, the higher court’s authority, and the judgment’s integrity. The result receives a new digest and parentJudgmentDigest; the previous revision remains in history.

The model distinguishes four outcomes:

A stay suspends execution while preserving the judgment and route of review. Remand returns article-iii:resolve-on-remand and removes the previous coercive remedy. Review completed by the Supreme Court receives finalWithinArticleIII. This field marks the boundary of the current prototype; it does not describe every real mechanism of rehearing, collateral review, or later proceedings.

stateDiagram-v2
    [*] --> РішенняПершоїІнстанції
    РішенняПершоїІнстанції --> Перегляд: належна скарга
    Перегляд --> Підтверджено: affirm
    Перегляд --> Замінено: reverse
    Перегляд --> Скасовано: vacate
    Перегляд --> Повернено: remand
    Повернено --> РішенняПершоїІнстанції: новий розгляд
    Підтверджено --> Завершено
    Замінено --> Завершено
    Скасовано --> Завершено

A final published judgment may enter the system as precedent. publishPrecedent() requires an authenticated publication, a precise ratio, links to holdings, and an enumerated binding scope. The full judgment and its applicable ratio remain distinct. The specification of stare decisis comes from later doctrine, and precedent’s actual force depends on court level, subject matter, and factual distinctions. The prototype proposes an engineering storage format and explicitly identifies it as a development beyond the original 1787 text.

The criminal route and the limit of judicial effectiveness

Article III requires jury trial for all crimes except impeachment and places the trial in the state where the crime was committed. For conduct outside any state, Congress determines the location by law. validateCriminalTrial() verifies these gates and sends impeachment to a separate Article I route.

The model intentionally does not include the entire criminal process. The Sixth Amendment develops the rights to a speedy and public trial, an impartial jury, notice, confrontation, compulsory process, and assistance of counsel. Rules of evidence, standards of charging, sentencing, and appellate review come from other constitutional provisions, statutes, and doctrine. The fifth function records only the framework directly necessary for a software interpretation of Article III.

The Treason Clause is especially expressive. The Constitution limits treason to two theories: levying War and adhering to Enemies by giving them Aid and Comfort. Conviction requires testimony from two witnesses to the same overt Act or a confession in open court. Congress determines punishment while preserving the prohibitions on corruption of blood and forfeiture beyond the convicted person’s life.

screenTreasonCharge() verifies the definition and evidentiary gate. Testimony about two different acts does not form the required pair. Duplicating one witness ID likewise does not create two witnesses. A successful check returns eligible-for-jury-determination and conviction: "not-determined-by-gateway". Guilt belongs to the trial; WARDEN confirms only eligibility to enter it.

This constraint has independent architectural value. Treason accusations are useful to power precisely because of their emotional breadth: a complex political conflict can be compressed into a label, after which the coercive stack cheerfully does the rest. The Constitution turns the label into a narrow type with an expensive evidentiary contract. The state machine can still kill people, but at least it is forbidden to treat an administrator’s enthusiasm as a valid data schema.

An executable judicial layer

Below is the complete ESM module for the fifth build. It imports only digest() from Article IV and accepts the normativeRoot and federation formed by earlier publications. The code runs in Node.js without external dependencies.

import { digest } from './article-iv.mjs';

export const ARTICLE_III = deepFreeze({
	id: 'U.S.Const.art.III',
	rules: {
		vesting:
			'III.1: the judicial power is vested in one Supreme Court and in inferior courts established by Congress',
		independence:
			'III.1: Article III judges hold office during good behaviour and their compensation may not be diminished while in office',
		enumeratedPower:
			'III.2.1: federal judicial power extends only to the enumerated cases and controversies',
		originalAndAppellate:
			'III.2.2: the Supreme Court has original jurisdiction in specified cases and appellate jurisdiction in the remainder, subject to constitutional regulations',
		juryAndVenue:
			'III.2.3: trials of crimes other than impeachment are by jury and use the constitutionally specified place of trial',
		treasonDefinition:
			'III.3.1: treason is limited to levying war or adhering to enemies by giving aid and comfort',
		treasonProof:
			'III.3.1: conviction for treason requires two witnesses to the same overt act or confession in open court',
		treasonPunishment:
			'III.3.2: Congress declares punishment, without corruption of blood or forfeiture beyond the life of the convicted person',
	},
	amendments: {
		eleventh:
			'Amendment XI modifies Article III by restricting specified suits against a state by out-of-state or foreign plaintiffs',
	},
	doctrine: {
		judicialReview:
			'Marbury v. Madison: a court deciding a case applies the Constitution over a conflicting ordinary rule within its jurisdiction',
		caseOrControversy:
			'Article III justiciability requires a concrete adverse dispute rather than an advisory opinion',
		standing: 'Modern standing doctrine asks for injury in fact, causation, and redressability',
		timing: 'Ripeness and mootness keep adjudication tied to a live dispute at the proper time',
		finality:
			'A final Article III judgment is a judicial act and is not silently reopened by another branch',
	},
	engineering: {
		provenRecord:
			'Constitution of Code III.2: a decision references an authenticated record and does not manufacture facts inside the resolver',
		explainableJudgment:
			'Constitution of Code III.3: every holding traces to findings, controlling authority, scope, disposition, and remedy',
		boundedRemedy:
			'Constitution of Code III.4: restoration is attributable, no broader than the proved injury, and handed to a separately authorized executor',
		immutableLineage:
			'Constitution of Code III.5: review creates a new judgment linked to the decision under review rather than rewriting history',
		wardenBoundary:
			'WARDEN verifies judicial invariants but cannot supply merits, findings, holdings, or punishment',
	},
});

export const JURISDICTION_HEADS = Object.freeze([
	'federal-question',
	'ambassadors-public-ministers-consuls',
	'admiralty-maritime',
	'united-states-party',
	'interstate',
	'state-and-out-of-state-citizen',
	'diversity',
	'competing-state-land-grants',
	'state-or-citizen-and-foreign-party',
]);

export const AUTHORITY_RANK = deepFreeze({
	constitution: 500,
	amendment: 500,
	'federal-statute': 400,
	treaty: 400,
	'binding-precedent': 350,
	'federal-regulation': 300,
	'state-constitution': 250,
	'state-law': 200,
	'persuasive-precedent': 100,
});

const DISPOSITIONS = Object.freeze(['grant-relief', 'deny-relief', 'dismiss-without-merits']);

const APPELLATE_OUTCOMES = Object.freeze(['affirm', 'reverse', 'vacate', 'remand']);

const TREASON_THEORIES = Object.freeze([
	'levying-war',
	'adhering-to-enemies-giving-aid-and-comfort',
]);

function deepFreeze(value) {
	if (value && typeof value === 'object' && !Object.isFrozen(value)) {
		Object.freeze(value);

		for (const nested of Object.values(value)) {
			deepFreeze(nested);
		}
	}

	return value;
}

function requireObject(value, label) {
	if (!value || typeof value !== 'object' || Array.isArray(value)) {
		throw new TypeError(`${label} must be an object`);
	}
}

function requireNonEmptyString(value, label) {
	if (typeof value !== 'string' || value.trim() === '') {
		throw new TypeError(`${label} must be a non-empty string`);
	}
}

function requireBoolean(value, label) {
	if (typeof value !== 'boolean') {
		throw new TypeError(`${label} must be a boolean`);
	}
}

function requireArray(value, label) {
	if (!Array.isArray(value)) {
		throw new TypeError(`${label} must be an array`);
	}
}

function requireUniqueStrings(values, label) {
	requireArray(values, label);

	for (const value of values) {
		requireNonEmptyString(value, `${label} item`);
	}

	if (new Set(values).size !== values.length) {
		throw new TypeError(`${label} must contain unique values`);
	}
}

function assertNormativeRoot(root) {
	requireNonEmptyString(root?.constitutionId, 'normativeRoot.constitutionId');
	requireNonEmptyString(root?.digest, 'normativeRoot.digest');

	if (root.status !== 'in-force') {
		throw new TypeError('normativeRoot must be in force');
	}
}

function assertJurisdictionHead(head) {
	if (!JURISDICTION_HEADS.includes(head)) {
		throw new TypeError(`Unsupported Article III jurisdiction head: ${head}`);
	}
}

function snapshotRoot(root) {
	return {
		constitutionId: root.constitutionId,
		digest: root.digest,
		status: root.status,
		parentDigest: root.parentDigest ?? null,
		amendmentDigest: root.amendmentDigest ?? null,
		lineage: [...(root.lineage ?? [root.digest])],
	};
}

function normalizeCourt(court) {
	requireNonEmptyString(court.id, 'court.id');

	if (!Number.isInteger(court.tier) || court.tier < 1) {
		throw new TypeError(`${court.id}.tier must be a positive integer`);
	}

	if (!['supreme', 'inferior'].includes(court.kind)) {
		throw new TypeError(`${court.id}.kind must be supreme or inferior`);
	}

	if (court.articleIII !== true) {
		throw new TypeError(`${court.id} must exercise Article III judicial power`);
	}

	if (court.kind === 'supreme' && court.establishedBy !== 'constitution') {
		throw new TypeError('The Supreme Court must be established by the Constitution');
	}

	if (court.kind === 'inferior' && court.establishedBy !== 'federal-statute') {
		throw new TypeError('An inferior Article III court requires a federal statute');
	}

	if (court.establishmentAuthenticated !== true) {
		throw new TypeError(`${court.id} requires an authenticated establishment source`);
	}

	requireUniqueStrings(court.originalHeads, `${court.id}.originalHeads`);
	requireUniqueStrings(court.appellateHeads, `${court.id}.appellateHeads`);

	for (const head of [...court.originalHeads, ...court.appellateHeads]) {
		assertJurisdictionHead(head);
	}

	return {
		id: court.id,
		name: court.name ?? court.id,
		kind: court.kind,
		tier: court.tier,
		articleIII: true,
		establishedBy: court.establishedBy,
		establishmentAuthenticated: true,
		originalHeads: [...court.originalHeads],
		appellateHeads: [...court.appellateHeads],
		venueStates: [...(court.venueStates ?? [])],
	};
}

function normalizeJudge(judge, courtIds) {
	requireNonEmptyString(judge.id, 'judge.id');
	requireNonEmptyString(judge.courtId, `${judge.id}.courtId`);

	if (!courtIds.has(judge.courtId)) {
		throw new TypeError(`Unknown court for judge ${judge.id}`);
	}

	if (judge.commissionAuthenticated !== true) {
		throw new TypeError(`${judge.id} requires an authenticated commission`);
	}

	if (judge.tenure !== 'good-behaviour') {
		throw new TypeError(`${judge.id} must hold office during good behaviour`);
	}

	if (judge.compensationProtection !== 'non-diminution') {
		throw new TypeError(`${judge.id} requires compensation non-diminution`);
	}

	return {
		id: judge.id,
		courtId: judge.courtId,
		commissionAuthenticated: true,
		tenure: judge.tenure,
		compensationProtection: judge.compensationProtection,
		active: judge.active !== false,
	};
}

export function constituteJudiciary({ normativeRoot, federation, courts, judges }) {
	assertNormativeRoot(normativeRoot);
	requireObject(federation, 'federation');
	requireArray(courts, 'courts');
	requireArray(judges, 'judges');

	if (federation.normativeRoot?.digest !== normativeRoot.digest) {
		throw new TypeError('Judiciary and federation must share the same root');
	}

	const normalizedCourts = courts.map(normalizeCourt);
	requireUniqueStrings(
		normalizedCourts.map((court) => court.id),
		'court ids',
	);

	const supremeCourts = normalizedCourts.filter((court) => court.kind === 'supreme');

	if (supremeCourts.length !== 1) {
		throw new TypeError('Article III requires exactly one Supreme Court');
	}

	const highestTier = Math.max(...normalizedCourts.map((court) => court.tier));

	if (supremeCourts[0].tier !== highestTier) {
		throw new TypeError('The Supreme Court must occupy the highest judicial tier');
	}

	const courtIds = new Set(normalizedCourts.map((court) => court.id));
	const normalizedJudges = judges.map((judge) => normalizeJudge(judge, courtIds));
	requireUniqueStrings(
		normalizedJudges.map((judge) => judge.id),
		'judge ids',
	);

	for (const court of normalizedCourts) {
		if (!normalizedJudges.some((judge) => judge.courtId === court.id && judge.active)) {
			throw new TypeError(`${court.id} requires at least one active Article III judge`);
		}
	}

	const topology = {
		rootDigest: normativeRoot.digest,
		federationId: federation.federationId,
		courts: normalizedCourts,
		judges: normalizedJudges,
	};

	return deepFreeze({
		judiciaryId: `judiciary:${digest(topology).slice(7, 23)}`,
		normativeRoot: snapshotRoot(normativeRoot),
		federationId: federation.federationId,
		federationTopologyDigest: federation.topologyDigest,
		courts: normalizedCourts,
		judges: normalizedJudges,
		topologyDigest: digest(topology),
		trace: [ARTICLE_III.rules.vesting, ARTICLE_III.rules.independence],
	});
}

function findCourt(judiciary, courtId) {
	requireNonEmptyString(courtId, 'courtId');
	const court = judiciary.courts.find((entry) => entry.id === courtId);

	if (!court) {
		throw new TypeError(`Unknown Article III court: ${courtId}`);
	}

	return court;
}

function failedCaseOrControversyChecks(caseOrControversy) {
	requireObject(caseOrControversy, 'petition.caseOrControversy');
	const failed = [];

	if (caseOrControversy.adverseParties !== true) failed.push('adverse-parties');
	if (caseOrControversy.injuryInFact !== true) failed.push('injury-in-fact');
	if (caseOrControversy.causation !== true) failed.push('causation');
	if (caseOrControversy.redressability !== true) failed.push('redressability');
	if (caseOrControversy.ripe !== true) failed.push('ripeness');
	if (caseOrControversy.live !== true) failed.push('mootness');

	return failed;
}

function isEleventhAmendmentDirectSuit(petition) {
	const directSuitAgainstState = petition.defendant?.kind === 'member-state';
	const restrictedHead = [
		'state-and-out-of-state-citizen',
		'state-or-citizen-and-foreign-party',
	].includes(petition.jurisdictionHead);

	return directSuitAgainstState && restrictedHead && petition.stateConsentAuthenticated !== true;
}

function validateArticleIVHandoff(sourceResult) {
	requireObject(sourceResult, 'sourceResult');

	const unresolvedStatuses = new Set([
		'requires-resolution',
		'requires-legal-classification',
		'requires-constitutional-determination',
	]);

	if (!unresolvedStatuses.has(sourceResult.status)) {
		throw new TypeError('sourceResult is not an unresolved Article IV state');
	}

	if (typeof sourceResult.handoff !== 'string' || !sourceResult.handoff.includes('article-iii')) {
		throw new TypeError('sourceResult does not authorize an Article III handoff');
	}
}

function docketContent(docket) {
	return {
		docketId: docket.docketId,
		judiciaryId: docket.judiciaryId,
		rootDigest: docket.rootDigest,
		courtId: docket.courtId,
		jurisdictionHead: docket.jurisdictionHead,
		filedAt: docket.filedAt,
		plaintiff: docket.plaintiff,
		defendant: docket.defendant,
		claim: docket.claim,
		requestedRelief: docket.requestedRelief,
		sourceDigest: docket.sourceDigest,
		caseOrControversy: docket.caseOrControversy,
		jurisdictionProof: docket.jurisdictionProof,
	};
}

export function docketCase({ judiciary, petition, sourceResult = null }) {
	requireObject(judiciary, 'judiciary');
	requireObject(petition, 'petition');
	requireNonEmptyString(petition.id, 'petition.id');
	requireNonEmptyString(petition.filedAt, 'petition.filedAt');
	requireNonEmptyString(petition.courtId, 'petition.courtId');
	requireNonEmptyString(petition.claim, 'petition.claim');
	requireObject(petition.plaintiff, 'petition.plaintiff');
	requireObject(petition.defendant, 'petition.defendant');
	requireObject(petition.requestedRelief, 'petition.requestedRelief');
	assertJurisdictionHead(petition.jurisdictionHead);

	const court = findCourt(judiciary, petition.courtId);
	const sourceDigest = sourceResult === null ? null : digest(sourceResult);

	if (sourceResult !== null) validateArticleIVHandoff(sourceResult);

	const failedChecks = failedCaseOrControversyChecks(petition.caseOrControversy);

	if (failedChecks.length > 0) {
		return deepFreeze({
			status: 'dismissed-without-merits',
			docketed: false,
			reason: 'no-justiciable-case-or-controversy',
			failedChecks,
			sourceDigest,
			trace: [
				ARTICLE_III.rules.enumeratedPower,
				ARTICLE_III.doctrine.caseOrControversy,
				ARTICLE_III.doctrine.standing,
				ARTICLE_III.doctrine.timing,
			],
		});
	}

	if (petition.caseOrControversy.politicalQuestionPotential === true) {
		return deepFreeze({
			status: 'requires-justiciability-determination',
			docketed: false,
			reason: 'political-question-potential-cannot-be-decided-by-intake-flag',
			sourceDigest,
			handoff: 'article-iii:judicial-threshold-review',
			trace: [ARTICLE_III.rules.enumeratedPower],
		});
	}

	if (isEleventhAmendmentDirectSuit(petition)) {
		return deepFreeze({
			status: 'dismissed-without-merits',
			docketed: false,
			reason: 'eleventh-amendment-direct-suit-bar',
			sourceDigest,
			trace: [ARTICLE_III.amendments.eleventh],
		});
	}

	const originalGrant = court.originalHeads.includes(petition.jurisdictionHead);

	if (petition.jurisdictionHead === 'interstate' && court.kind !== 'supreme') {
		return deepFreeze({
			status: 'wrong-forum',
			docketed: false,
			reason: 'interstate-controversy-requires-supreme-original-route',
			requiredCourtKind: 'supreme',
			sourceDigest,
			trace: [ARTICLE_III.rules.originalAndAppellate],
		});
	}

	if (!originalGrant) {
		return deepFreeze({
			status: 'wrong-forum',
			docketed: false,
			reason: 'court-lacks-proved-original-jurisdiction-grant',
			sourceDigest,
			trace: [ARTICLE_III.rules.enumeratedPower, ARTICLE_III.rules.originalAndAppellate],
		});
	}

	const content = {
		docketId: `case:${petition.id}`,
		judiciaryId: judiciary.judiciaryId,
		rootDigest: judiciary.normativeRoot.digest,
		courtId: court.id,
		jurisdictionHead: petition.jurisdictionHead,
		filedAt: petition.filedAt,
		plaintiff: petition.plaintiff,
		defendant: petition.defendant,
		claim: petition.claim,
		requestedRelief: petition.requestedRelief,
		sourceDigest,
		caseOrControversy: { ...petition.caseOrControversy },
		jurisdictionProof: {
			originalGrantVerified: true,
			courtEstablishmentAuthenticated: court.establishmentAuthenticated,
			stateConsentAuthenticated: petition.stateConsentAuthenticated === true,
			interstateOriginalRoute: petition.jurisdictionHead === 'interstate',
		},
	};

	return deepFreeze({
		status: 'docketed',
		docketed: true,
		...content,
		caseDigest: digest(content),
		trace: [
			ARTICLE_III.rules.enumeratedPower,
			ARTICLE_III.doctrine.caseOrControversy,
			ARTICLE_III.doctrine.standing,
		],
	});
}

function assertDocket(judiciary, docket) {
	if (docket?.status !== 'docketed' || docket.docketed !== true) {
		throw new TypeError('A docketed Article III case is required');
	}

	if (docket.judiciaryId !== judiciary.judiciaryId) {
		throw new TypeError('Docket belongs to another judiciary');
	}

	if (docket.rootDigest !== judiciary.normativeRoot.digest) {
		throw new TypeError('Docket belongs to another constitutional root');
	}

	if (docket.caseDigest !== digest(docketContent(docket))) {
		throw new TypeError('Docket integrity check failed');
	}
}

function recordContent(record) {
	return {
		caseDigest: record.caseDigest,
		closedAt: record.closedAt,
		factFinder: record.factFinder,
		evidence: record.evidence,
		findings: record.findings,
	};
}

export function closeRecord({ judiciary, docket, closedAt, factFinder, evidence, findings }) {
	assertDocket(judiciary, docket);
	requireNonEmptyString(closedAt, 'closedAt');
	requireObject(factFinder, 'factFinder');
	requireNonEmptyString(factFinder.id, 'factFinder.id');
	requireNonEmptyString(factFinder.kind, 'factFinder.kind');

	if (factFinder.authorityVerified !== true) {
		throw new TypeError('Fact finder authority must be verified');
	}

	requireArray(evidence, 'evidence');
	requireArray(findings, 'findings');
	requireUniqueStrings(
		evidence.map((item) => item.id),
		'evidence ids',
	);
	requireUniqueStrings(
		findings.map((item) => item.id),
		'finding ids',
	);

	const normalizedEvidence = evidence.map((item) => {
		requireNonEmptyString(item.id, 'evidence.id');
		requireNonEmptyString(item.kind, `${item.id}.kind`);
		requireArray(item.propositions, `${item.id}.propositions`);

		return {
			id: item.id,
			kind: item.kind,
			authenticated: item.authenticated === true,
			admitted: item.admitted === true,
			propositions: [...item.propositions],
		};
	});
	const evidenceById = new Map(normalizedEvidence.map((item) => [item.id, item]));
	const normalizedFindings = findings.map((finding) => {
		requireNonEmptyString(finding.id, 'finding.id');
		requireNonEmptyString(finding.proposition, `${finding.id}.proposition`);
		requireUniqueStrings(finding.supportedBy, `${finding.id}.supportedBy`);

		if (finding.supportedBy.length === 0) {
			throw new TypeError(`${finding.id} requires record support`);
		}

		for (const evidenceId of finding.supportedBy) {
			const item = evidenceById.get(evidenceId);

			if (!item) throw new TypeError(`Unknown evidence reference: ${evidenceId}`);
			if (!item.authenticated) {
				throw new TypeError(`Unauthenticated evidence cannot support ${finding.id}`);
			}
			if (!item.admitted) {
				throw new TypeError(`Excluded evidence cannot support ${finding.id}`);
			}
		}

		return {
			id: finding.id,
			proposition: finding.proposition,
			supportedBy: [...finding.supportedBy],
		};
	});
	const content = {
		caseDigest: docket.caseDigest,
		closedAt,
		factFinder: {
			id: factFinder.id,
			kind: factFinder.kind,
			authorityVerified: true,
		},
		evidence: normalizedEvidence,
		findings: normalizedFindings,
	};

	return deepFreeze({
		status: 'record-closed',
		...content,
		recordDigest: digest(content),
		trace: [ARTICLE_III.engineering.provenRecord],
	});
}

function assertRecord(docket, record) {
	if (record?.status !== 'record-closed') {
		throw new TypeError('A closed evidentiary record is required');
	}

	if (record.caseDigest !== docket.caseDigest) {
		throw new TypeError('Record belongs to another case');
	}

	if (record.recordDigest !== digest(recordContent(record))) {
		throw new TypeError('Record integrity check failed');
	}
}

function normalizeAuthorities(judiciary, authorities) {
	requireArray(authorities, 'authorities');
	requireUniqueStrings(
		authorities.map((authority) => authority.id),
		'authority ids',
	);

	return authorities.map((authority) => {
		requireNonEmptyString(authority.id, 'authority.id');
		requireNonEmptyString(authority.kind, `${authority.id}.kind`);
		requireNonEmptyString(authority.citation, `${authority.id}.citation`);

		if (!(authority.kind in AUTHORITY_RANK)) {
			throw new TypeError(`Unsupported authority kind: ${authority.kind}`);
		}

		if (authority.authorityVerified !== true || authority.status !== 'in-force') {
			throw new TypeError(`${authority.id} is not a verified in-force authority`);
		}

		if (
			['constitution', 'amendment'].includes(authority.kind) &&
			authority.rootDigest !== judiciary.normativeRoot.digest
		) {
			throw new TypeError(`${authority.id} belongs to another constitutional root`);
		}

		if (authority.kind === 'federal-statute' && authority.madeInPursuanceVerified !== true) {
			throw new TypeError(`${authority.id} lacks a pursuance determination`);
		}

		if (authority.kind === 'treaty' && authority.underAuthorityVerified !== true) {
			throw new TypeError(`${authority.id} lacks an authority determination`);
		}

		requireUniqueStrings(authority.displacedBy ?? [], `${authority.id}.displacedBy`);

		return {
			id: authority.id,
			kind: authority.kind,
			citation: authority.citation,
			rootDigest: authority.rootDigest ?? null,
			status: authority.status,
			authorityVerified: true,
			rank: AUTHORITY_RANK[authority.kind],
			displacedBy: [...(authority.displacedBy ?? [])],
		};
	});
}

function validateRemedy(disposition, remedy) {
	requireObject(remedy, 'decision.remedy');
	requireNonEmptyString(remedy.type, 'decision.remedy.type');

	if (remedy.type === 'none') {
		if (disposition === 'grant-relief') {
			throw new TypeError('Granted relief requires a remedy');
		}

		return {
			type: 'none',
			target: null,
			operation: null,
			scope: null,
			executableBy: null,
			redressesInjury: false,
			leastScopeVerified: true,
			reversibleUntilFinal: false,
		};
	}

	requireNonEmptyString(remedy.target, 'decision.remedy.target');
	requireNonEmptyString(remedy.operation, 'decision.remedy.operation');
	requireNonEmptyString(remedy.scope, 'decision.remedy.scope');
	requireNonEmptyString(remedy.executableBy, 'decision.remedy.executableBy');

	if (remedy.redressesInjury !== true) {
		throw new TypeError('Remedy must be capable of redressing the proved injury');
	}

	if (remedy.leastScopeVerified !== true) {
		throw new TypeError('Remedy exceeds the verified scope of the case');
	}

	requireBoolean(remedy.reversibleUntilFinal, 'decision.remedy.reversibleUntilFinal');

	return {
		type: remedy.type,
		target: remedy.target,
		operation: remedy.operation,
		scope: remedy.scope,
		executableBy: remedy.executableBy,
		redressesInjury: true,
		leastScopeVerified: true,
		reversibleUntilFinal: remedy.reversibleUntilFinal,
	};
}

function judgmentContent(judgment) {
	return {
		judgmentId: judgment.judgmentId,
		judiciaryId: judgment.judiciaryId,
		rootDigest: judgment.rootDigest,
		caseDigest: judgment.caseDigest,
		recordDigest: judgment.recordDigest,
		courtId: judgment.courtId,
		courtTier: judgment.courtTier,
		jurisdictionHead: judgment.jurisdictionHead,
		decidedAt: judgment.decidedAt,
		disposition: judgment.disposition,
		holdings: judgment.holdings,
		remedy: judgment.remedy,
		sourceDigest: judgment.sourceDigest,
		parentJudgmentDigest: judgment.parentJudgmentDigest ?? null,
		appellateOutcome: judgment.appellateOutcome ?? null,
	};
}

export function resolve({ judiciary, docket, record, authorities, decision }) {
	assertDocket(judiciary, docket);
	assertRecord(docket, record);
	requireObject(decision, 'decision');
	requireNonEmptyString(decision.decidedAt, 'decision.decidedAt');

	if (!DISPOSITIONS.includes(decision.disposition)) {
		throw new TypeError('Unsupported judicial disposition');
	}

	const court = findCourt(judiciary, docket.courtId);
	const normalizedAuthorities = normalizeAuthorities(judiciary, authorities);
	const authorityById = new Map(
		normalizedAuthorities.map((authority) => [authority.id, authority]),
	);
	const findingIds = new Set(record.findings.map((finding) => finding.id));
	requireArray(decision.holdings, 'decision.holdings');
	requireUniqueStrings(
		decision.holdings.map((holding) => holding.id),
		'holding ids',
	);

	if (decision.holdings.length === 0) {
		throw new TypeError('A merits decision requires at least one holding');
	}

	const holdings = decision.holdings.map((holding) => {
		requireNonEmptyString(holding.id, 'holding.id');
		requireNonEmptyString(holding.issue, `${holding.id}.issue`);
		requireNonEmptyString(holding.conclusion, `${holding.id}.conclusion`);
		requireNonEmptyString(holding.scope, `${holding.id}.scope`);
		requireUniqueStrings(holding.authorityIds, `${holding.id}.authorityIds`);
		requireUniqueStrings(holding.findingIds, `${holding.id}.findingIds`);

		if (holding.authorityIds.length === 0) {
			throw new TypeError(`${holding.id} requires controlling authority`);
		}

		for (const authorityId of holding.authorityIds) {
			const authority = authorityById.get(authorityId);

			if (!authority) throw new TypeError(`Unknown authority reference: ${authorityId}`);

			for (const higherId of authority.displacedBy) {
				const higher = authorityById.get(higherId);

				if (!higher) {
					throw new TypeError(`Missing displaced-by authority: ${higherId}`);
				}

				if (!holding.authorityIds.includes(higherId)) {
					throw new TypeError(
						`${authorityId} cannot control without its displacing authority ${higherId}`,
					);
				}

				if (higher.rank < authority.rank) {
					throw new TypeError('Authority hierarchy is internally inconsistent');
				}
			}
		}

		for (const findingId of holding.findingIds) {
			if (!findingIds.has(findingId)) {
				throw new TypeError(`Unknown finding reference: ${findingId}`);
			}
		}

		return {
			id: holding.id,
			issue: holding.issue,
			conclusion: holding.conclusion,
			scope: holding.scope,
			authorityIds: [...holding.authorityIds],
			findingIds: [...holding.findingIds],
		};
	});
	const remedy = validateRemedy(decision.disposition, decision.remedy);
	const content = {
		judgmentId: `judgment:${docket.docketId}:${decision.decidedAt}`,
		judiciaryId: judiciary.judiciaryId,
		rootDigest: judiciary.normativeRoot.digest,
		caseDigest: docket.caseDigest,
		recordDigest: record.recordDigest,
		courtId: court.id,
		courtTier: court.tier,
		jurisdictionHead: docket.jurisdictionHead,
		decidedAt: decision.decidedAt,
		disposition: decision.disposition,
		holdings,
		remedy,
		sourceDigest: docket.sourceDigest,
		parentJudgmentDigest: null,
		appellateOutcome: null,
	};
	const finalWithinArticleIII = court.kind === 'supreme';

	return deepFreeze({
		status: 'judgment-entered',
		...content,
		judgmentDigest: digest(content),
		finalAtLevel: true,
		finalWithinArticleIII,
		review: finalWithinArticleIII ? 'article-iii-complete' : 'appellate-review-available',
		execution: remedy.type === 'none' ? 'no-coercive-remedy' : 'pending-separate-execution',
		handoff: remedy.type === 'none' ? 'case-closed' : 'article-ii:execute',
		trace: [
			ARTICLE_III.rules.enumeratedPower,
			ARTICLE_III.doctrine.judicialReview,
			ARTICLE_III.engineering.provenRecord,
			ARTICLE_III.engineering.explainableJudgment,
			ARTICLE_III.engineering.boundedRemedy,
		],
	});
}

function assertJudgment(judiciary, judgment) {
	if (judgment?.status !== 'judgment-entered') {
		throw new TypeError('An entered Article III judgment is required');
	}

	if (judgment.judiciaryId !== judiciary.judiciaryId) {
		throw new TypeError('Judgment belongs to another judiciary');
	}

	if (judgment.judgmentDigest !== digest(judgmentContent(judgment))) {
		throw new TypeError('Judgment integrity check failed');
	}
}

export function reviewJudgment({
	judiciary,
	judgment,
	appellateCourtId,
	notice,
	appellateDecision,
}) {
	assertJudgment(judiciary, judgment);
	const lowerCourt = findCourt(judiciary, judgment.courtId);
	const appellateCourt = findCourt(judiciary, appellateCourtId);
	requireObject(notice, 'notice');
	requireObject(appellateDecision, 'appellateDecision');

	const noticeValid =
		notice.authenticated === true &&
		notice.timely === true &&
		notice.judgmentDigest === judgment.judgmentDigest;

	if (!noticeValid) {
		return deepFreeze({
			status: 'review-denied',
			reason: 'invalid-or-untimely-notice',
			judgmentDigest: judgment.judgmentDigest,
			trace: [ARTICLE_III.rules.originalAndAppellate],
		});
	}

	if (
		appellateCourt.tier <= lowerCourt.tier ||
		!appellateCourt.appellateHeads.includes(judgment.jurisdictionHead)
	) {
		return deepFreeze({
			status: 'review-denied',
			reason: 'court-lacks-proved-appellate-jurisdiction',
			judgmentDigest: judgment.judgmentDigest,
			trace: [ARTICLE_III.rules.originalAndAppellate],
		});
	}

	if (!APPELLATE_OUTCOMES.includes(appellateDecision.outcome)) {
		throw new TypeError('Unsupported appellate outcome');
	}

	requireNonEmptyString(appellateDecision.decidedAt, 'appellateDecision.decidedAt');
	requireNonEmptyString(appellateDecision.reason, 'appellateDecision.reason');

	let disposition = judgment.disposition;
	let holdings = judgment.holdings;
	let remedy = judgment.remedy;

	if (appellateDecision.outcome === 'reverse') {
		if (!DISPOSITIONS.includes(appellateDecision.replacementDisposition)) {
			throw new TypeError('Reverse requires a replacement disposition');
		}

		disposition = appellateDecision.replacementDisposition;
		holdings = appellateDecision.replacementHoldings ?? judgment.holdings;
		remedy = validateRemedy(disposition, appellateDecision.replacementRemedy);
	}

	if (['vacate', 'remand'].includes(appellateDecision.outcome)) {
		disposition = 'dismiss-without-merits';
		remedy = validateRemedy(disposition, { type: 'none' });
	}

	const content = {
		judgmentId: `judgment:${judgment.caseDigest}:${appellateDecision.decidedAt}`,
		judiciaryId: judiciary.judiciaryId,
		rootDigest: judiciary.normativeRoot.digest,
		caseDigest: judgment.caseDigest,
		recordDigest: judgment.recordDigest,
		courtId: appellateCourt.id,
		courtTier: appellateCourt.tier,
		jurisdictionHead: judgment.jurisdictionHead,
		decidedAt: appellateDecision.decidedAt,
		disposition,
		holdings,
		remedy,
		sourceDigest: judgment.sourceDigest,
		parentJudgmentDigest: judgment.judgmentDigest,
		appellateOutcome: appellateDecision.outcome,
	};
	const finalWithinArticleIII =
		appellateCourt.kind === 'supreme' && appellateDecision.outcome !== 'remand';
	const executionStayed = notice.stayGranted === true;

	return deepFreeze({
		status: 'judgment-entered',
		...content,
		judgmentDigest: digest(content),
		finalAtLevel: true,
		finalWithinArticleIII,
		review:
			appellateDecision.outcome === 'remand'
				? 'returned-to-lower-court'
				: finalWithinArticleIII
					? 'article-iii-complete'
					: 'further-review-may-be-available',
		execution:
			appellateDecision.outcome === 'remand'
				? 'suspended-on-remand'
				: executionStayed
					? 'stayed'
					: remedy.type === 'none'
						? 'no-coercive-remedy'
						: 'pending-separate-execution',
		handoff:
			appellateDecision.outcome === 'remand'
				? 'article-iii:resolve-on-remand'
				: remedy.type === 'none'
					? 'case-closed'
					: 'article-ii:execute',
		mandate: {
			outcome: appellateDecision.outcome,
			reason: appellateDecision.reason,
			executionStayed,
		},
		trace: [
			ARTICLE_III.rules.originalAndAppellate,
			ARTICLE_III.engineering.immutableLineage,
			ARTICLE_III.doctrine.finality,
		],
	});
}

export function publishPrecedent({ judiciary, judgment, publication }) {
	assertJudgment(judiciary, judgment);
	requireObject(publication, 'publication');

	if (judgment.finalWithinArticleIII !== true) {
		return deepFreeze({
			status: 'precedent-not-published',
			reason: 'judgment-not-final-within-article-iii',
			judgmentDigest: judgment.judgmentDigest,
			trace: [ARTICLE_III.doctrine.finality],
		});
	}

	if (publication.authenticated !== true) {
		throw new TypeError('Precedent publication must be authenticated');
	}

	requireNonEmptyString(publication.citation, 'publication.citation');
	requireNonEmptyString(publication.ratio, 'publication.ratio');
	requireUniqueStrings(publication.holdingIds, 'publication.holdingIds');
	requireUniqueStrings(publication.bindingCourtIds, 'publication.bindingCourtIds');
	const holdingIds = new Set(judgment.holdings.map((holding) => holding.id));
	const courtIds = new Set(judiciary.courts.map((court) => court.id));

	for (const holdingId of publication.holdingIds) {
		if (!holdingIds.has(holdingId)) {
			throw new TypeError(`Unknown holding in ratio: ${holdingId}`);
		}
	}

	for (const courtId of publication.bindingCourtIds) {
		if (!courtIds.has(courtId)) {
			throw new TypeError(`Unknown court in precedent scope: ${courtId}`);
		}
	}

	const content = {
		precedentId: `precedent:${publication.citation}`,
		judgmentDigest: judgment.judgmentDigest,
		rootDigest: judiciary.normativeRoot.digest,
		citation: publication.citation,
		ratio: publication.ratio,
		holdingIds: [...publication.holdingIds],
		bindingCourtIds: [...publication.bindingCourtIds],
	};

	return deepFreeze({
		status: 'precedent-published',
		...content,
		precedentDigest: digest(content),
		trace: [ARTICLE_III.doctrine.finality, ARTICLE_III.engineering.explainableJudgment],
	});
}

export function validateCriminalTrial({ judiciary, trial }) {
	requireObject(judiciary, 'judiciary');
	requireObject(trial, 'trial');
	requireNonEmptyString(trial.caseId, 'trial.caseId');

	if (trial.kind === 'impeachment') {
		return deepFreeze({
			status: 'outside-article-iii-criminal-jury-route',
			valid: null,
			handoff: 'article-i:impeachment-trial',
			trace: [ARTICLE_III.rules.juryAndVenue],
		});
	}

	if (trial.kind !== 'criminal') {
		throw new TypeError('Unsupported trial kind');
	}

	const failedChecks = [];

	if (trial.juryVerified !== true) failedChecks.push('jury');

	if (trial.offenseState !== null) {
		requireNonEmptyString(trial.offenseState, 'trial.offenseState');

		if (trial.venueState !== trial.offenseState) failedChecks.push('state-venue');
	} else if (
		trial.congressionallyDirectedVenue !== true ||
		typeof trial.venuePlace !== 'string' ||
		trial.venuePlace.trim() === ''
	) {
		failedChecks.push('outside-state-venue');
	}

	return deepFreeze({
		status: failedChecks.length === 0 ? 'trial-route-valid' : 'trial-route-defective',
		valid: failedChecks.length === 0,
		failedChecks,
		trace: [ARTICLE_III.rules.juryAndVenue],
	});
}

export function screenTreasonCharge({ charge, evidence }) {
	requireObject(charge, 'charge');
	requireNonEmptyString(charge.id, 'charge.id');
	requireNonEmptyString(charge.theory, 'charge.theory');
	requireArray(evidence, 'evidence');

	if (!TREASON_THEORIES.includes(charge.theory)) {
		return deepFreeze({
			status: 'charge-rejected',
			eligibleForJury: false,
			reason: 'conduct-outside-constitutional-treason-definition',
			trace: [ARTICLE_III.rules.treasonDefinition],
		});
	}

	const openCourtConfession = evidence.some(
		(item) =>
			item.kind === 'open-court-confession' &&
			item.authenticated === true &&
			item.admitted === true,
	);
	const witnessesByOvertAct = new Map();

	for (const item of evidence) {
		if (
			item.kind !== 'witness-testimony' ||
			item.authenticated !== true ||
			item.admitted !== true
		) {
			continue;
		}

		requireNonEmptyString(item.witnessId, 'witness-testimony.witnessId');
		requireNonEmptyString(item.overtActId, 'witness-testimony.overtActId');
		const witnesses = witnessesByOvertAct.get(item.overtActId) ?? new Set();
		witnesses.add(item.witnessId);
		witnessesByOvertAct.set(item.overtActId, witnesses);
	}

	const qualifyingOvertAct =
		[...witnessesByOvertAct.entries()].find(([, witnesses]) => witnesses.size >= 2)?.[0] ?? null;
	const proofGatewaySatisfied = openCourtConfession || qualifyingOvertAct !== null;

	return deepFreeze({
		status: proofGatewaySatisfied
			? 'eligible-for-jury-determination'
			: 'treason-proof-gateway-not-satisfied',
		eligibleForJury: proofGatewaySatisfied,
		openCourtConfession,
		qualifyingOvertAct,
		conviction: 'not-determined-by-gateway',
		trace: [ARTICLE_III.rules.treasonDefinition, ARTICLE_III.rules.treasonProof],
	});
}

export function validateTreasonSentence({ sentence }) {
	requireObject(sentence, 'sentence');
	const failedChecks = [];

	if (sentence.punishmentAuthorizedByCongress !== true) {
		failedChecks.push('congressional-punishment-authority');
	}

	if (sentence.corruptionOfBlood === true) failedChecks.push('corruption-of-blood');
	if (sentence.forfeitureBeyondLife === true) failedChecks.push('forfeiture-beyond-life');

	return deepFreeze({
		status: failedChecks.length === 0 ? 'sentence-within-article-iii' : 'sentence-rejected',
		valid: failedChecks.length === 0,
		failedChecks,
		trace: [ARTICLE_III.rules.treasonPunishment],
	});
}

WARDEN: seventy scenarios for judicial power

WARDEN tests seventy scenarios in the fifth build. Each test declares the source of its invariant: the literal text of Article III, the Eleventh Amendment, judicial doctrine, or an engineering rule from Code Constitution.

One principal negative invariant runs through the entire corpus: WARDEN creates no finding, holding, remedy, guilt, or punishment. It can stop a damaged pipeline and identify the point of failure. The substantive decision remains with an established court and the evidentiary record.

import test from 'node:test';
import assert from 'node:assert/strict';

import {
	ARTICLE_IV,
	federate,
	issueInterstateArtifact,
	recognizeInterstateArtifact,
} from './article-iv.mjs';

import {
	ARTICLE_III,
	closeRecord,
	constituteJudiciary,
	docketCase,
	publishPrecedent,
	resolve,
	reviewJudgment,
	screenTreasonCharge,
	validateCriminalTrial,
	validateTreasonSentence,
} from './article-iii.mjs';

function wardenTest(name, sourceClauses, scenario) {
	test(name, () => {
		assert.ok(Array.isArray(sourceClauses) && sourceClauses.length > 0);
		assert.ok(sourceClauses.every((source) => typeof source === 'string'));
		scenario();
	});
}

const normativeRoot = Object.freeze({
	constitutionId: 'Constitution of 1787+amendment:xi+amendment:xiii+amendment:test',
	digest: 'sha256:root-after-article-v',
	parentDigest: 'sha256:root-before-article-v',
	amendmentDigest: 'sha256:amendment-test',
	status: 'in-force',
	lineage: Object.freeze([
		'sha256:root-before-article-v',
		'sha256:amendment:xi',
		'sha256:amendment:xiii',
		'sha256:root-after-article-v',
	]),
});

const states = Object.freeze([
	{
		id: 'Franklin',
		constitutionDigest: 'sha256:franklin',
		admittedAt: '1788-01-01',
		republicanFormVerified: true,
	},
	{
		id: 'Hamilton',
		constitutionDigest: 'sha256:hamilton',
		admittedAt: '1788-02-01',
		republicanFormVerified: true,
	},
	{
		id: 'Madison',
		constitutionDigest: 'sha256:madison',
		admittedAt: '1788-03-01',
		republicanFormVerified: true,
	},
]);

const federation = federate({ normativeRoot, states });

const courts = Object.freeze([
	{
		id: 'court:district-hamilton',
		name: 'District Court for Hamilton',
		kind: 'inferior',
		tier: 1,
		articleIII: true,
		establishedBy: 'federal-statute',
		establishmentAuthenticated: true,
		originalHeads: [
			'federal-question',
			'admiralty-maritime',
			'united-states-party',
			'state-and-out-of-state-citizen',
			'diversity',
			'competing-state-land-grants',
			'state-or-citizen-and-foreign-party',
		],
		appellateHeads: [],
		venueStates: ['Hamilton'],
	},
	{
		id: 'court:circuit',
		name: 'Circuit Court',
		kind: 'inferior',
		tier: 2,
		articleIII: true,
		establishedBy: 'federal-statute',
		establishmentAuthenticated: true,
		originalHeads: [],
		appellateHeads: ['federal-question', 'admiralty-maritime', 'united-states-party', 'diversity'],
		venueStates: [],
	},
	{
		id: 'court:supreme',
		name: 'Supreme Court',
		kind: 'supreme',
		tier: 3,
		articleIII: true,
		establishedBy: 'constitution',
		establishmentAuthenticated: true,
		originalHeads: [
			'ambassadors-public-ministers-consuls',
			'interstate',
			'united-states-party',
			'state-and-out-of-state-citizen',
			'state-or-citizen-and-foreign-party',
		],
		appellateHeads: [
			'federal-question',
			'ambassadors-public-ministers-consuls',
			'admiralty-maritime',
			'united-states-party',
			'state-and-out-of-state-citizen',
			'diversity',
			'competing-state-land-grants',
			'state-or-citizen-and-foreign-party',
		],
		venueStates: [],
	},
]);

const judges = Object.freeze([
	{
		id: 'judge:district',
		courtId: 'court:district-hamilton',
		commissionAuthenticated: true,
		tenure: 'good-behaviour',
		compensationProtection: 'non-diminution',
	},
	{
		id: 'judge:circuit',
		courtId: 'court:circuit',
		commissionAuthenticated: true,
		tenure: 'good-behaviour',
		compensationProtection: 'non-diminution',
	},
	{
		id: 'judge:supreme',
		courtId: 'court:supreme',
		commissionAuthenticated: true,
		tenure: 'good-behaviour',
		compensationProtection: 'non-diminution',
	},
]);

const judiciary = constituteJudiciary({
	normativeRoot,
	federation,
	courts,
	judges,
});

const interstateJudgment = issueInterstateArtifact({
	federation,
	issuerState: 'Franklin',
	id: 'judgment:franklin:42',
	artifactClass: 'final-judgment',
	revision: 'r1',
	issuedAt: '2026-08-09',
	issuingAuthority: 'Franklin Superior Court',
	authorityScope: 'civil-money-judgment',
	final: true,
	stayed: false,
	payload: { debtor: 'Ada', creditor: 'Grace', amount: 500 },
	effectAtOrigin: 'enforce-money-judgment',
});

const unresolvedArticleIV = recognizeInterstateArtifact({
	federation,
	receivingState: 'Hamilton',
	artifact: interstateJudgment,
	proof: {
		authenticated: true,
		integrityDigest: interstateJudgment.digest,
		revisionVerified: true,
		originCompetenceVerified: true,
	},
	requestedEffect: 'imprison-debtor',
});

function petition(overrides = {}) {
	return {
		id: 'grace-v-hamilton',
		filedAt: '2026-08-09',
		courtId: 'court:district-hamilton',
		jurisdictionHead: 'federal-question',
		plaintiff: { id: 'Grace', kind: 'natural-person', state: 'Franklin' },
		defendant: { id: 'Hamilton Enforcement Office', kind: 'state-agency', state: 'Hamilton' },
		claim: 'Article IV permits only the effect attached to the judgment at origin',
		requestedRelief: {
			type: 'declaratory-and-injunctive',
			operation: 'limit-local-execution-to-origin-effect',
		},
		caseOrControversy: {
			adverseParties: true,
			injuryInFact: true,
			causation: true,
			redressability: true,
			ripe: true,
			live: true,
			politicalQuestionPotential: false,
		},
		...overrides,
	};
}

function docket(overrides = {}, sourceResult = unresolvedArticleIV) {
	return docketCase({
		judiciary,
		petition: petition(overrides),
		sourceResult,
	});
}

function closedRecord(docketValue = docket(), overrides = {}) {
	return closeRecord({
		judiciary,
		docket: docketValue,
		closedAt: '2026-08-10',
		factFinder: {
			id: 'judge:district',
			kind: 'judge',
			authorityVerified: true,
		},
		evidence: [
			{
				id: 'evidence:origin-judgment',
				kind: 'authenticated-judicial-record',
				authenticated: true,
				admitted: true,
				propositions: ['the origin judgment authorizes a money judgment'],
			},
			{
				id: 'evidence:requested-effect',
				kind: 'stipulation',
				authenticated: true,
				admitted: true,
				propositions: ['Hamilton requested imprisonment as the receiving effect'],
			},
		],
		findings: [
			{
				id: 'finding:origin-effect',
				proposition: "The judgment's effect at origin is enforcement of a money judgment",
				supportedBy: ['evidence:origin-judgment'],
			},
			{
				id: 'finding:requested-effect',
				proposition: 'The requested receiving effect is imprisonment of the debtor',
				supportedBy: ['evidence:requested-effect'],
			},
		],
		...overrides,
	});
}

function authoritySet(overrides = {}) {
	const values = [
		{
			id: 'authority:article-iv',
			kind: 'constitution',
			citation: 'U.S. Const. art. IV, sec. 1',
			rootDigest: normativeRoot.digest,
			status: 'in-force',
			authorityVerified: true,
			displacedBy: [],
		},
		{
			id: 'authority:28-usc-1738',
			kind: 'federal-statute',
			citation: '28 U.S.C. § 1738',
			status: 'in-force',
			authorityVerified: true,
			madeInPursuanceVerified: true,
			displacedBy: [],
		},
		{
			id: 'authority:hamilton-enforcement',
			kind: 'state-law',
			citation: 'Hamilton Enforcement Rule 9',
			status: 'in-force',
			authorityVerified: true,
			displacedBy: ['authority:article-iv'],
		},
	];

	if (overrides.replaceAt !== undefined) {
		values[overrides.replaceAt] = overrides.value;
	}

	return overrides.values ?? values;
}

function meritsDecision(overrides = {}) {
	return {
		decidedAt: '2026-08-11',
		disposition: 'grant-relief',
		holdings: [
			{
				id: 'holding:same-effect',
				issue: "May the receiving state enlarge the origin judgment's effect?",
				conclusion: 'The receiving state may not replace a money judgment with imprisonment',
				scope: 'This authenticated final judgment and the requested receiving effect',
				authorityIds: [
					'authority:article-iv',
					'authority:28-usc-1738',
					'authority:hamilton-enforcement',
				],
				findingIds: ['finding:origin-effect', 'finding:requested-effect'],
			},
		],
		remedy: {
			type: 'injunction',
			target: 'Hamilton Enforcement Office',
			operation: 'limit-execution-to-enforce-money-judgment',
			scope: 'judgment:franklin:42',
			executableBy: 'article-ii:marshal-service',
			redressesInjury: true,
			leastScopeVerified: true,
			reversibleUntilFinal: true,
		},
		...overrides,
	};
}

function enteredJudgment(options = {}) {
	const docketValue = options.docketValue ?? docket();
	const recordValue = options.recordValue ?? closedRecord(docketValue);

	return resolve({
		judiciary,
		docket: docketValue,
		record: recordValue,
		authorities: options.authorities ?? authoritySet(),
		decision: options.decision ?? meritsDecision(),
	});
}

wardenTest(
	'constituteJudiciary binds the court system to the Article V root and Article IV federation',
	[ARTICLE_III.rules.vesting],
	() => {
		assert.equal(judiciary.normativeRoot.digest, normativeRoot.digest);
		assert.equal(judiciary.federationId, federation.federationId);
		assert.equal(judiciary.courts.length, 3);
	},
);

wardenTest(
	'constituteJudiciary rejects a federation from another root',
	[ARTICLE_III.rules.vesting],
	() => {
		assert.throws(
			() =>
				constituteJudiciary({
					normativeRoot: { ...normativeRoot, digest: 'sha256:other-root' },
					federation,
					courts,
					judges,
				}),
			/same root/,
		);
	},
);

wardenTest('Article III requires one Supreme Court', [ARTICLE_III.rules.vesting], () => {
	assert.throws(
		() =>
			constituteJudiciary({
				normativeRoot,
				federation,
				courts: courts.slice(0, 2),
				judges: judges.slice(0, 2),
			}),
		/exactly one Supreme Court/,
	);
});

wardenTest(
	'Article III rejects two components claiming to be the Supreme Court',
	[ARTICLE_III.rules.vesting],
	() => {
		const duplicate = { ...courts[2], id: 'court:supreme-copy' };
		const duplicateJudge = { ...judges[2], id: 'judge:supreme-copy', courtId: duplicate.id };
		assert.throws(
			() =>
				constituteJudiciary({
					normativeRoot,
					federation,
					courts: [...courts, duplicate],
					judges: [...judges, duplicateJudge],
				}),
			/exactly one Supreme Court/,
		);
	},
);

wardenTest(
	'an inferior Article III court requires statutory establishment',
	[ARTICLE_III.rules.vesting],
	() => {
		const altered = [{ ...courts[0], establishedBy: 'executive-order' }, ...courts.slice(1)];
		assert.throws(
			() => constituteJudiciary({ normativeRoot, federation, courts: altered, judges }),
			/requires a federal statute/,
		);
		const unauthenticated = [
			{ ...courts[0], establishmentAuthenticated: false },
			...courts.slice(1),
		];
		assert.throws(
			() => constituteJudiciary({ normativeRoot, federation, courts: unauthenticated, judges }),
			/authenticated establishment source/,
		);
	},
);

wardenTest(
	'every active Article III court requires an active judge',
	[ARTICLE_III.rules.vesting, ARTICLE_III.rules.independence],
	() => {
		assert.throws(
			() => constituteJudiciary({ normativeRoot, federation, courts, judges: judges.slice(1) }),
			/requires at least one active/,
		);
	},
);

wardenTest(
	'annual judicial renewal fails the good-behaviour tenure invariant',
	[ARTICLE_III.rules.independence],
	() => {
		const altered = [{ ...judges[0], tenure: 'annual-renewal' }, ...judges.slice(1)];
		assert.throws(
			() => constituteJudiciary({ normativeRoot, federation, courts, judges: altered }),
			/good behaviour/,
		);
	},
);

wardenTest(
	'diminishable judicial pay fails the independence invariant',
	[ARTICLE_III.rules.independence],
	() => {
		const altered = [
			{ ...judges[0], compensationProtection: 'budget-discretion' },
			...judges.slice(1),
		];
		assert.throws(
			() => constituteJudiciary({ normativeRoot, federation, courts, judges: altered }),
			/non-diminution/,
		);
	},
);

wardenTest(
	'judicial topology is deeply immutable',
	[ARTICLE_III.engineering.immutableLineage],
	() => {
		assert.equal(Object.isFrozen(judiciary), true);
		assert.equal(Object.isFrozen(judiciary.courts), true);
		assert.throws(() => judiciary.courts.push(courts[0]));
	},
);

wardenTest(
	'a real Article IV failure enters the Article III docket',
	[ARTICLE_IV.engineering.safeDispute, ARTICLE_III.rules.enumeratedPower],
	() => {
		const result = docket();
		assert.equal(unresolvedArticleIV.status, 'requires-resolution');
		assert.equal(result.status, 'docketed');
		assert.equal(result.sourceDigest !== null, true);
	},
);

wardenTest(
	'a resolved Article IV result cannot be relabeled as an unresolved handoff',
	[ARTICLE_IV.engineering.safeDispute, ARTICLE_III.engineering.wardenBoundary],
	() => {
		assert.throws(
			() => docket({}, { status: 'recognized', handoff: 'article-iii:resolve' }),
			/not an unresolved/,
		);
	},
);

wardenTest(
	'an unresolved source without an Article III handoff remains outside the docket',
	[ARTICLE_III.rules.enumeratedPower],
	() => {
		assert.throws(
			() => docket({}, { status: 'requires-resolution', handoff: 'executive-transfer' }),
			/does not authorize/,
		);
	},
);

wardenTest(
	'an unenumerated jurisdiction label cannot create judicial power',
	[ARTICLE_III.rules.enumeratedPower],
	() => {
		assert.throws(
			() => docket({ jurisdictionHead: 'general-public-interest' }),
			/Unsupported Article III/,
		);
	},
);

for (const [field, expected] of [
	['adverseParties', 'adverse-parties'],
	['injuryInFact', 'injury-in-fact'],
	['causation', 'causation'],
	['redressability', 'redressability'],
	['ripe', 'ripeness'],
	['live', 'mootness'],
]) {
	wardenTest(
		`a petition without ${field} is dismissed without reaching the merits`,
		[
			ARTICLE_III.doctrine.caseOrControversy,
			ARTICLE_III.doctrine.standing,
			ARTICLE_III.doctrine.timing,
		],
		() => {
			const result = docket({
				caseOrControversy: { ...petition().caseOrControversy, [field]: false },
			});
			assert.equal(result.status, 'dismissed-without-merits');
			assert.ok(result.failedChecks.includes(expected));
		},
	);
}

wardenTest(
	'a possible political question receives judicial threshold review instead of a test-suite verdict',
	[ARTICLE_III.engineering.wardenBoundary],
	() => {
		const result = docket({
			caseOrControversy: { ...petition().caseOrControversy, politicalQuestionPotential: true },
		});
		assert.equal(result.status, 'requires-justiciability-determination');
		assert.equal(result.handoff, 'article-iii:judicial-threshold-review');
	},
);

wardenTest(
	'the Eleventh Amendment blocks the modeled direct suit against an unconsenting state',
	[ARTICLE_III.amendments.eleventh],
	() => {
		const result = docket({
			jurisdictionHead: 'state-and-out-of-state-citizen',
			defendant: { id: 'Hamilton', kind: 'member-state', state: 'Hamilton' },
		});
		assert.equal(result.reason, 'eleventh-amendment-direct-suit-bar');
	},
);

wardenTest(
	"authenticated state consent passes the prototype's Eleventh Amendment gate",
	[ARTICLE_III.amendments.eleventh],
	() => {
		const result = docket({
			jurisdictionHead: 'state-and-out-of-state-citizen',
			defendant: { id: 'Hamilton', kind: 'member-state', state: 'Hamilton' },
			stateConsentAuthenticated: true,
		});
		assert.equal(result.status, 'docketed');
		assert.equal(result.jurisdictionProof.stateConsentAuthenticated, true);
	},
);

wardenTest(
	'an interstate controversy cannot begin in the modeled district court',
	[ARTICLE_III.rules.originalAndAppellate],
	() => {
		const result = docket({
			jurisdictionHead: 'interstate',
			plaintiff: { id: 'Franklin', kind: 'member-state' },
			defendant: { id: 'Hamilton', kind: 'member-state' },
		});
		assert.equal(result.status, 'wrong-forum');
		assert.equal(result.requiredCourtKind, 'supreme');
	},
);

wardenTest(
	"an interstate controversy enters the Supreme Court's original route",
	[ARTICLE_III.rules.originalAndAppellate],
	() => {
		const result = docket({
			courtId: 'court:supreme',
			jurisdictionHead: 'interstate',
			plaintiff: { id: 'Franklin', kind: 'member-state' },
			defendant: { id: 'Hamilton', kind: 'member-state' },
		});
		assert.equal(result.status, 'docketed');
	},
);

wardenTest(
	'a federal question enters a statutorily granted inferior-court route',
	[ARTICLE_III.rules.enumeratedPower, ARTICLE_III.rules.originalAndAppellate],
	() => {
		assert.equal(docket().courtId, 'court:district-hamilton');
	},
);

wardenTest(
	'a court cannot acquire original jurisdiction by receiving a petition',
	[ARTICLE_III.rules.originalAndAppellate],
	() => {
		const result = docket({ courtId: 'court:circuit' });
		assert.equal(result.status, 'wrong-forum');
		assert.equal(result.reason, 'court-lacks-proved-original-jurisdiction-grant');
	},
);

wardenTest(
	'an authenticated admitted record supports explicit findings',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		const result = closedRecord();
		assert.equal(result.status, 'record-closed');
		assert.equal(result.findings.length, 2);
	},
);

wardenTest('a finding cannot cite unknown evidence', [ARTICLE_III.engineering.provenRecord], () => {
	assert.throws(
		() =>
			closedRecord(docket(), {
				findings: [{ id: 'finding:x', proposition: 'x', supportedBy: ['evidence:missing'] }],
			}),
		/Unknown evidence/,
	);
});

wardenTest(
	'unauthenticated evidence cannot support a finding',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		assert.throws(
			() =>
				closedRecord(docket(), {
					evidence: [
						{
							id: 'evidence:x',
							kind: 'document',
							authenticated: false,
							admitted: true,
							propositions: ['x'],
						},
					],
					findings: [{ id: 'finding:x', proposition: 'x', supportedBy: ['evidence:x'] }],
				}),
			/Unauthenticated evidence/,
		);
	},
);

wardenTest(
	'excluded evidence cannot support a finding',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		assert.throws(
			() =>
				closedRecord(docket(), {
					evidence: [
						{
							id: 'evidence:x',
							kind: 'document',
							authenticated: true,
							admitted: false,
							propositions: ['x'],
						},
					],
					findings: [{ id: 'finding:x', proposition: 'x', supportedBy: ['evidence:x'] }],
				}),
			/Excluded evidence/,
		);
	},
);

wardenTest(
	'a record cannot contain an unsupported finding',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		assert.throws(
			() =>
				closedRecord(docket(), {
					findings: [{ id: 'finding:x', proposition: 'x', supportedBy: [] }],
				}),
			/requires record support/,
		);
	},
);

wardenTest(
	'an unauthorized fact finder cannot close the record',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		assert.throws(
			() =>
				closedRecord(docket(), {
					factFinder: { id: 'warden', kind: 'test-runner', authorityVerified: false },
				}),
			/authority must be verified/,
		);
	},
);

wardenTest('the closed record is deeply immutable', [ARTICLE_III.engineering.provenRecord], () => {
	const result = closedRecord();
	assert.equal(Object.isFrozen(result.findings), true);
	assert.throws(() => result.findings.push(result.findings[0]));
});

wardenTest(
	'resolve enters an explainable judgment for the Article IV dispute',
	[ARTICLE_III.engineering.explainableJudgment],
	() => {
		const result = enteredJudgment();
		assert.equal(result.status, 'judgment-entered');
		assert.equal(result.disposition, 'grant-relief');
		assert.equal(result.holdings[0].findingIds.length, 2);
	},
);

wardenTest(
	'resolve preserves the source handoff instead of rewriting Article IV history',
	[ARTICLE_III.engineering.immutableLineage],
	() => {
		const before = JSON.stringify(unresolvedArticleIV);
		const result = enteredJudgment();
		assert.equal(JSON.stringify(unresolvedArticleIV), before);
		assert.equal(result.sourceDigest, docket().sourceDigest);
	},
);

wardenTest(
	'a record from another case cannot be used for judgment',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		const firstDocket = docket();
		const otherDocket = docket({ id: 'other-case' });
		assert.throws(
			() => enteredJudgment({ docketValue: firstDocket, recordValue: closedRecord(otherDocket) }),
			/another case/,
		);
	},
);

wardenTest(
	'an unverified authority cannot control a holding',
	[ARTICLE_III.doctrine.judicialReview],
	() => {
		const altered = authoritySet({
			replaceAt: 1,
			value: { ...authoritySet()[1], authorityVerified: false },
		});
		assert.throws(
			() => enteredJudgment({ authorities: altered }),
			/not a verified in-force authority/,
		);
	},
);

wardenTest(
	'a constitutional authority from another root is rejected',
	[ARTICLE_III.doctrine.judicialReview],
	() => {
		const altered = authoritySet({
			replaceAt: 0,
			value: { ...authoritySet()[0], rootDigest: 'sha256:foreign-root' },
		});
		assert.throws(() => enteredJudgment({ authorities: altered }), /another constitutional root/);
	},
);

wardenTest(
	'a federal statute requires a pursuance determination',
	[ARTICLE_III.doctrine.judicialReview],
	() => {
		const altered = authoritySet({
			replaceAt: 1,
			value: { ...authoritySet()[1], madeInPursuanceVerified: false },
		});
		assert.throws(
			() => enteredJudgment({ authorities: altered }),
			/lacks a pursuance determination/,
		);
	},
);

wardenTest(
	'a displaced state rule cannot control without the superior authority in the trace',
	[ARTICLE_III.doctrine.judicialReview, ARTICLE_III.engineering.explainableJudgment],
	() => {
		const decision = meritsDecision({
			holdings: [
				{ ...meritsDecision().holdings[0], authorityIds: ['authority:hamilton-enforcement'] },
			],
		});
		assert.throws(() => enteredJudgment({ decision }), /cannot control without/);
	},
);

wardenTest(
	'a holding cannot cite a finding absent from the closed record',
	[ARTICLE_III.engineering.provenRecord],
	() => {
		const decision = meritsDecision({
			holdings: [{ ...meritsDecision().holdings[0], findingIds: ['finding:invented'] }],
		});
		assert.throws(() => enteredJudgment({ decision }), /Unknown finding/);
	},
);

wardenTest(
	'a holding cannot cite an authority absent from the authority set',
	[ARTICLE_III.engineering.explainableJudgment],
	() => {
		const decision = meritsDecision({
			holdings: [{ ...meritsDecision().holdings[0], authorityIds: ['authority:invented'] }],
		});
		assert.throws(() => enteredJudgment({ decision }), /Unknown authority/);
	},
);

wardenTest(
	'a remedy broader than the verified scope is rejected',
	[ARTICLE_III.engineering.boundedRemedy],
	() => {
		const decision = meritsDecision({
			remedy: { ...meritsDecision().remedy, leastScopeVerified: false },
		});
		assert.throws(() => enteredJudgment({ decision }), /exceeds the verified scope/);
	},
);

wardenTest(
	'a remedy incapable of redress is rejected',
	[ARTICLE_III.doctrine.standing, ARTICLE_III.engineering.boundedRemedy],
	() => {
		const decision = meritsDecision({
			remedy: { ...meritsDecision().remedy, redressesInjury: false },
		});
		assert.throws(() => enteredJudgment({ decision }), /capable of redressing/);
	},
);

wardenTest(
	'denial of relief may close a case without a coercive remedy',
	[ARTICLE_III.engineering.boundedRemedy],
	() => {
		const decision = meritsDecision({
			disposition: 'deny-relief',
			remedy: { type: 'none' },
		});
		const result = enteredJudgment({ decision });
		assert.equal(result.handoff, 'case-closed');
		assert.equal(result.execution, 'no-coercive-remedy');
	},
);

wardenTest(
	'a granted remedy is handed to Article II instead of being executed by resolve',
	[ARTICLE_III.engineering.boundedRemedy],
	() => {
		const result = enteredJudgment();
		assert.equal(result.execution, 'pending-separate-execution');
		assert.equal(result.handoff, 'article-ii:execute');
	},
);

wardenTest(
	'entered judgments are deeply immutable',
	[ARTICLE_III.engineering.immutableLineage],
	() => {
		const result = enteredJudgment();
		assert.equal(Object.isFrozen(result), true);
		assert.throws(() => result.holdings.push(result.holdings[0]));
	},
);

wardenTest(
	'a valid notice creates an appellate judgment linked to the lower judgment',
	[ARTICLE_III.rules.originalAndAppellate, ARTICLE_III.engineering.immutableLineage],
	() => {
		const lower = enteredJudgment();
		const reviewed = reviewJudgment({
			judiciary,
			judgment: lower,
			appellateCourtId: 'court:circuit',
			notice: { authenticated: true, timely: true, judgmentDigest: lower.judgmentDigest },
			appellateDecision: {
				outcome: 'affirm',
				decidedAt: '2026-08-12',
				reason: 'no reversible error',
			},
		});
		assert.equal(reviewed.status, 'judgment-entered');
		assert.equal(reviewed.parentJudgmentDigest, lower.judgmentDigest);
	},
);

wardenTest(
	'an invalid notice cannot start appellate review',
	[ARTICLE_III.rules.originalAndAppellate],
	() => {
		const lower = enteredJudgment();
		const reviewed = reviewJudgment({
			judiciary,
			judgment: lower,
			appellateCourtId: 'court:circuit',
			notice: { authenticated: false, timely: true, judgmentDigest: lower.judgmentDigest },
			appellateDecision: { outcome: 'affirm', decidedAt: '2026-08-12', reason: 'unused' },
		});
		assert.equal(reviewed.status, 'review-denied');
	},
);

wardenTest(
	'a court at the same tier cannot review the judgment',
	[ARTICLE_III.rules.originalAndAppellate],
	() => {
		const lower = enteredJudgment();
		const reviewed = reviewJudgment({
			judiciary,
			judgment: lower,
			appellateCourtId: 'court:district-hamilton',
			notice: { authenticated: true, timely: true, judgmentDigest: lower.judgmentDigest },
			appellateDecision: { outcome: 'affirm', decidedAt: '2026-08-12', reason: 'unused' },
		});
		assert.equal(reviewed.reason, 'court-lacks-proved-appellate-jurisdiction');
	},
);

wardenTest(
	'a granted stay suspends execution while review proceeds',
	[ARTICLE_III.rules.originalAndAppellate],
	() => {
		const lower = enteredJudgment();
		const reviewed = reviewJudgment({
			judiciary,
			judgment: lower,
			appellateCourtId: 'court:circuit',
			notice: {
				authenticated: true,
				timely: true,
				stayGranted: true,
				judgmentDigest: lower.judgmentDigest,
			},
			appellateDecision: { outcome: 'affirm', decidedAt: '2026-08-12', reason: 'merits affirmed' },
		});
		assert.equal(reviewed.execution, 'stayed');
	},
);

wardenTest(
	'remand returns the dispute to resolve without preserving the old remedy',
	[ARTICLE_III.engineering.immutableLineage],
	() => {
		const lower = enteredJudgment();
		const reviewed = reviewJudgment({
			judiciary,
			judgment: lower,
			appellateCourtId: 'court:circuit',
			notice: { authenticated: true, timely: true, judgmentDigest: lower.judgmentDigest },
			appellateDecision: {
				outcome: 'remand',
				decidedAt: '2026-08-12',
				reason: 'record requires new findings',
			},
		});
		assert.equal(reviewed.handoff, 'article-iii:resolve-on-remand');
		assert.equal(reviewed.remedy.type, 'none');
	},
);

wardenTest(
	'Supreme Court review can complete the Article III lineage',
	[ARTICLE_III.rules.originalAndAppellate, ARTICLE_III.doctrine.finality],
	() => {
		const lower = enteredJudgment();
		const circuit = reviewJudgment({
			judiciary,
			judgment: lower,
			appellateCourtId: 'court:circuit',
			notice: { authenticated: true, timely: true, judgmentDigest: lower.judgmentDigest },
			appellateDecision: { outcome: 'affirm', decidedAt: '2026-08-12', reason: 'affirmed' },
		});
		const supreme = reviewJudgment({
			judiciary,
			judgment: circuit,
			appellateCourtId: 'court:supreme',
			notice: { authenticated: true, timely: true, judgmentDigest: circuit.judgmentDigest },
			appellateDecision: {
				outcome: 'affirm',
				decidedAt: '2026-08-13',
				reason: 'constitutional effect confirmed',
			},
		});
		assert.equal(supreme.finalWithinArticleIII, true);
		assert.equal(supreme.review, 'article-iii-complete');
	},
);

function finalSupremeJudgment() {
	const lower = enteredJudgment();
	const circuit = reviewJudgment({
		judiciary,
		judgment: lower,
		appellateCourtId: 'court:circuit',
		notice: { authenticated: true, timely: true, judgmentDigest: lower.judgmentDigest },
		appellateDecision: { outcome: 'affirm', decidedAt: '2026-08-12', reason: 'affirmed' },
	});

	return reviewJudgment({
		judiciary,
		judgment: circuit,
		appellateCourtId: 'court:supreme',
		notice: { authenticated: true, timely: true, judgmentDigest: circuit.judgmentDigest },
		appellateDecision: { outcome: 'affirm', decidedAt: '2026-08-13', reason: 'affirmed' },
	});
}

wardenTest(
	'a final authenticated opinion can publish a bounded precedent',
	[ARTICLE_III.doctrine.finality, ARTICLE_III.engineering.explainableJudgment],
	() => {
		const result = publishPrecedent({
			judiciary,
			judgment: finalSupremeJudgment(),
			publication: {
				authenticated: true,
				citation: 'Protocol Reports 1',
				ratio: 'A receiving state may not enlarge a final judgment beyond its effect at origin',
				holdingIds: ['holding:same-effect'],
				bindingCourtIds: ['court:district-hamilton', 'court:circuit'],
			},
		});
		assert.equal(result.status, 'precedent-published');
	},
);

wardenTest(
	'a reviewable lower judgment is not published as final precedent by this prototype',
	[ARTICLE_III.doctrine.finality],
	() => {
		const result = publishPrecedent({
			judiciary,
			judgment: enteredJudgment(),
			publication: {
				authenticated: true,
				citation: 'Draft Reports 1',
				ratio: 'draft',
				holdingIds: ['holding:same-effect'],
				bindingCourtIds: ['court:district-hamilton'],
			},
		});
		assert.equal(result.status, 'precedent-not-published');
	},
);

wardenTest(
	'a ratio cannot cite a holding absent from the judgment',
	[ARTICLE_III.engineering.explainableJudgment],
	() => {
		assert.throws(
			() =>
				publishPrecedent({
					judiciary,
					judgment: finalSupremeJudgment(),
					publication: {
						authenticated: true,
						citation: 'Protocol Reports 2',
						ratio: 'invented',
						holdingIds: ['holding:invented'],
						bindingCourtIds: ['court:circuit'],
					},
				}),
			/Unknown holding/,
		);
	},
);

wardenTest(
	'a criminal jury trial in the state of the offense satisfies the Article III route',
	[ARTICLE_III.rules.juryAndVenue],
	() => {
		const result = validateCriminalTrial({
			judiciary,
			trial: {
				caseId: 'criminal:1',
				kind: 'criminal',
				juryVerified: true,
				offenseState: 'Hamilton',
				venueState: 'Hamilton',
			},
		});
		assert.equal(result.status, 'trial-route-valid');
	},
);

wardenTest(
	'a non-impeachment criminal trial without a jury is defective',
	[ARTICLE_III.rules.juryAndVenue],
	() => {
		const result = validateCriminalTrial({
			judiciary,
			trial: {
				caseId: 'criminal:2',
				kind: 'criminal',
				juryVerified: false,
				offenseState: 'Hamilton',
				venueState: 'Hamilton',
			},
		});
		assert.ok(result.failedChecks.includes('jury'));
	},
);

wardenTest(
	'a criminal trial in the wrong state is defective',
	[ARTICLE_III.rules.juryAndVenue],
	() => {
		const result = validateCriminalTrial({
			judiciary,
			trial: {
				caseId: 'criminal:3',
				kind: 'criminal',
				juryVerified: true,
				offenseState: 'Franklin',
				venueState: 'Hamilton',
			},
		});
		assert.ok(result.failedChecks.includes('state-venue'));
	},
);

wardenTest(
	'an offense outside every state uses a congressionally directed place',
	[ARTICLE_III.rules.juryAndVenue],
	() => {
		const result = validateCriminalTrial({
			judiciary,
			trial: {
				caseId: 'criminal:4',
				kind: 'criminal',
				juryVerified: true,
				offenseState: null,
				congressionallyDirectedVenue: true,
				venuePlace: 'Federal District',
			},
		});
		assert.equal(result.valid, true);
	},
);

wardenTest(
	"impeachment is routed outside Article III's criminal jury trial",
	[ARTICLE_III.rules.juryAndVenue],
	() => {
		const result = validateCriminalTrial({
			judiciary,
			trial: { caseId: 'impeachment:1', kind: 'impeachment' },
		});
		assert.equal(result.handoff, 'article-i:impeachment-trial');
	},
);

wardenTest(
	'two distinct witnesses to the same overt act pass the treason proof gateway',
	[ARTICLE_III.rules.treasonDefinition, ARTICLE_III.rules.treasonProof],
	() => {
		const result = screenTreasonCharge({
			charge: { id: 'treason:1', theory: 'levying-war' },
			evidence: [
				{
					kind: 'witness-testimony',
					witnessId: 'W1',
					overtActId: 'act:bridge',
					authenticated: true,
					admitted: true,
				},
				{
					kind: 'witness-testimony',
					witnessId: 'W2',
					overtActId: 'act:bridge',
					authenticated: true,
					admitted: true,
				},
			],
		});
		assert.equal(result.status, 'eligible-for-jury-determination');
		assert.equal(result.conviction, 'not-determined-by-gateway');
	},
);

wardenTest(
	'two witnesses to different overt acts do not satisfy the treason gateway',
	[ARTICLE_III.rules.treasonProof],
	() => {
		const result = screenTreasonCharge({
			charge: { id: 'treason:2', theory: 'levying-war' },
			evidence: [
				{
					kind: 'witness-testimony',
					witnessId: 'W1',
					overtActId: 'act:a',
					authenticated: true,
					admitted: true,
				},
				{
					kind: 'witness-testimony',
					witnessId: 'W2',
					overtActId: 'act:b',
					authenticated: true,
					admitted: true,
				},
			],
		});
		assert.equal(result.eligibleForJury, false);
	},
);

wardenTest(
	'duplicating one witness does not manufacture the constitutional pair',
	[ARTICLE_III.rules.treasonProof],
	() => {
		const result = screenTreasonCharge({
			charge: { id: 'treason:3', theory: 'levying-war' },
			evidence: [
				{
					kind: 'witness-testimony',
					witnessId: 'W1',
					overtActId: 'act:a',
					authenticated: true,
					admitted: true,
				},
				{
					kind: 'witness-testimony',
					witnessId: 'W1',
					overtActId: 'act:a',
					authenticated: true,
					admitted: true,
				},
			],
		});
		assert.equal(result.eligibleForJury, false);
	},
);

wardenTest(
	'an authenticated confession in open court passes the alternative treason gateway',
	[ARTICLE_III.rules.treasonProof],
	() => {
		const result = screenTreasonCharge({
			charge: { id: 'treason:4', theory: 'adhering-to-enemies-giving-aid-and-comfort' },
			evidence: [{ kind: 'open-court-confession', authenticated: true, admitted: true }],
		});
		assert.equal(result.openCourtConfession, true);
		assert.equal(result.eligibleForJury, true);
	},
);

wardenTest(
	'conduct outside the constitutional definition is rejected as a treason charge',
	[ARTICLE_III.rules.treasonDefinition],
	() => {
		const result = screenTreasonCharge({
			charge: { id: 'treason:5', theory: 'criticizing-the-government' },
			evidence: [],
		});
		assert.equal(result.status, 'charge-rejected');
	},
);

wardenTest(
	'a congressionally authorized treason sentence can remain within Article III',
	[ARTICLE_III.rules.treasonPunishment],
	() => {
		const result = validateTreasonSentence({
			sentence: {
				punishmentAuthorizedByCongress: true,
				corruptionOfBlood: false,
				forfeitureBeyondLife: false,
			},
		});
		assert.equal(result.status, 'sentence-within-article-iii');
	},
);

wardenTest('corruption of blood is rejected', [ARTICLE_III.rules.treasonPunishment], () => {
	const result = validateTreasonSentence({
		sentence: {
			punishmentAuthorizedByCongress: true,
			corruptionOfBlood: true,
			forfeitureBeyondLife: false,
		},
	});
	assert.ok(result.failedChecks.includes('corruption-of-blood'));
});

wardenTest(
	"forfeiture beyond the convicted person's life is rejected",
	[ARTICLE_III.rules.treasonPunishment],
	() => {
		const result = validateTreasonSentence({
			sentence: {
				punishmentAuthorizedByCongress: true,
				corruptionOfBlood: false,
				forfeitureBeyondLife: true,
			},
		});
		assert.ok(result.failedChecks.includes('forfeiture-beyond-life'));
	},
);

wardenTest(
	'WARDEN never converts the treason gateway into a conviction',
	[ARTICLE_III.engineering.wardenBoundary],
	() => {
		const result = screenTreasonCharge({
			charge: { id: 'treason:6', theory: 'levying-war' },
			evidence: [
				{
					kind: 'witness-testimony',
					witnessId: 'W1',
					overtActId: 'act:a',
					authenticated: true,
					admitted: true,
				},
				{
					kind: 'witness-testimony',
					witnessId: 'W2',
					overtActId: 'act:a',
					authenticated: true,
					admitted: true,
				},
			],
		});
		assert.equal(result.conviction, 'not-determined-by-gateway');
		assert.equal('guilty' in result, false);
	},
);

The check runs with:

node --test work/article-iii.test.mjs

Result for the current revision:

tests 70
pass 70
fail 0

Running the fourth and fifth builds together confirms 112 scenarios: forty-two federal and seventy judicial. The integration test creates a real requires-resolution result through Article IV’s recognizeInterstateArtifact() and then carries it through the Article III docket, record, and judgment.

What Article III gives software architecture

The fifth build offers several transferable principles.

The first principle requires a concrete conflict. An architectural resolver receives parties, affected state, causation, and an attainable outcome. A general question with no owner of the injury and no possible remedy belongs to policy design, documentation, or a legislative process.

The second principle ties competence to event type. A component receives enumerated jurisdiction heads and separate grants. An incoming packet does not enlarge its authority. This model is useful for support systems, plugin arbitration, policy engines, and internal governance procedures.

The third principle separates the record from reasoning. Evidence receives provenance and an admission state, findings cite evidence, and holdings cite findings and authorities. An LLM can help assemble an explanation, check reference completeness, and detect conflict. The source of each fact and responsibility for each conclusion remain visible.

The fourth principle makes remedy a separate object. It contains a target, operation, scope, executor, and connection to the proved injury. The judgment goes to an executive component and receives no unlimited direct access to the runtime.

The fifth principle stores review as lineage. Affirm, reverse, vacate, and remand create new states while preserving the original judgment. Precedent is published as a linked ratio with an explicit scope, not as a mystical property of the entire opinion.

The sixth principle strengthens checks for politically dangerous operations. The more readily an accusation can bypass ordinary classification, the narrower its input schema and the more expensive its proof threshold should be. Article III demonstrates this principle in treason with striking engineering clarity.

Where the fifth experiment ends

The prototype retains substantial limits.

It models modern standing through six authenticated characteristics and does not reproduce every exception, special right, form of representational standing, or distinction between constitutional and prudential doctrine. Ripeness, mootness, and the political-question doctrine are reduced to observable gates even though real disputes about them require argument and adjudication.

The jurisdiction registry uses pre-supplied congressional grants. It does not cover removal, supplemental jurisdiction, abstention, sovereign immunity in its full modern form, personal jurisdiction, venue statutes, or the complex boundary between Article III courts and Article I tribunals. The Eleventh Amendment appears as a narrow direct-suit gate with consent, while modern doctrine is considerably richer.

Authority rank protects a known hierarchy; it does not establish meaning. Judicial interpretation, selection of applicable law, standards of review, and reconciliation of precedents require human legal judgment. madeInPursuanceVerified also arrives from outside; whether a statute conforms to the Constitution is often the issue in the case itself.

The record stores provenance and references while leaving credibility, burdens of proof, evidentiary objections, and the formation of a jury verdict outside the model. Remedy is limited to a general contract and does not reproduce the differences among damages, injunctions, declaratory relief, habeas, vacatur, and many specialized remedies.

The finalWithinArticleIII field marks a convenient experimental boundary. Actual finality depends on court level, time, rehearing, collateral proceedings, and the nature of the judgment. Precedential force also comes from doctrine and institutional practice rather than a single flag.

The principal limit concerns execution. A judgment can define an admissible state and a required act, yet changing the material world requires people, institutions, money, access, and sometimes coercion. The next article will hand the remedy to the presidential control plane. It will ask whether the executive can comply with a judgment that limits the executive’s own freedom of action. That unit test usually gives power a sudden interest in “flexible interpretation of requirements.”

Conclusion

Article III turns a common normative architecture into a mechanism for resolving concrete conflicts. It establishes an independent circuit of judicial power, limits it to enumerated cases and controversies, routes original and appellate jurisdiction, requires special criminal procedure, and protects the law of treason from politically convenient vagueness.

The software interpretation adds a traceable record, typed authorities, holdings linked to facts and law, a bounded remedy, and immutable review lineage. The model passes seventy WARDEN scenarios and successfully accepts an unresolved state from Article IV. It also confirms the cycle’s original hypothesis: a substantial part of constitutional architecture can be expressed as executable contracts while semantic decisions remain with people and institutions holding proved authority.

After the fifth build, America can bootstrap, identify a trusted revision, update its kernel, connect autonomous states, and resolve conflicts among them. The judgment now exists. Someone must execute it, apply admissible means, and leave a verifiable trace.

The next function is execute().

Continue the research with AI

The site renders this section from the independent question set constitution-runtime.article-iii.resolve, stored in the companion catalog constitution-runtime-05-article-iii-questions.yaml. Every prompt independently identifies its Article III subject, constitutional or doctrinal source, prototype object, and adjudicative boundary, allowing it to operate outside the article’s linear sequence without losing context.

The recommended route is independent court → case or controversy → jurisdiction → evidentiary record → judicial review → bounded remedy → appeal and precedent → criminal safeguards → WARDEN → limits. The bilingual catalog contains the AI answer contract, sixty standalone prompts, branch triggers, code and visual references, and return navigation.

Publication information

Authors: Sam Starling, Oksana Dubinetska
Project context: Zhovten Games / IRONCREED
Complete research source: Code Constitution — DOI 10.5281/zenodo.21894242
Research repository: FOP-Oksana-Dubinetska/code-constitution
Historical, legal, and technical materials: text of the United States Constitution; overview of Article III; Judicial Vesting Clause; protection of federal judicial independence; Cases or Controversies; advisory opinions; standing; Lujan test; ripeness; mootness; Marbury v. Madison and judicial review; Supreme Court original jurisdiction; 28 U.S.C. § 1251; Eleventh Amendment; history of the Treason Clause; levying war; aid and comfort; finality of Article III court judgments
Related publications: “Connect America: How Article VII Bootstraps a Republic”; “What America Trusts: How Article VI Assembles the Supreme Order”; “Update America: How Article V Changes the Constitutional Kernel”; “Link America: How Article IV Turns the States into a Federal Network”
Next publication: Article II — in development
Publication revision: 0.2 · 13 August 2026