Розсудити Америку: як стаття III перетворює конфлікт на виконуване рішення

Вихідне питання

Як система може прийняти конкретний конфлікт, довести власне право його розглядати, відокремити встановлені факти від тверджень сторін, обрати чинну норму, ухвалити обмежене рішення та повернути порушену область до допустимого стану?

Повна дослідницька основа цієї публічної адаптації доступна на Zenodo: «Конституція коду».

На карті з’являється червона лінія

Підключена Америка в Death Stranding створює приємне відчуття спільної інфраструктури. Дороги з’єднуються, чужі мости входять до нашого маршруту, станції приймають один протокол, а карта поступово перестає нагадувати набір ізольованих плям. Четверта публікація відтворила саме цей стан: стаття IV перетворила штати на автономні вузли спільної федеративної мережі й визначила, як внутрішні кордони перетинають акти, записи, судові рішення, громадяни та обов’язки.

Спільна мережа відразу створює новий клас подій. Два вузли можуть визнати існування одного артефакту й водночас сперечатися про його ефект. Штат, що приймає, може отримати автентичне судове рішення та вимагати виконання, якого воно ніколи не мало у вихідній юрисдикції. Громадянин може зіткнутися з відмінними умовами й стверджувати, що така різниця порушує захищене становище. Федеральне правило може претендувати на верховенство, а локальна норма — на власну предметну компетенцію. Зв’язність робить конфлікт спостережуваним і переносним.

У попередній збірці такі події отримували стан requires-resolution, призупиняли небезпечну операцію та передавалися за адресою article-iii:resolve. Це була навмисна межа статті IV. Федеративний протокол може перевірити походження пакета, його цілісність, редакцію, компетенцію та запитуваний ефект. Юридично спірний результат потребує іншого повноваження, іншої процедури й іншого носія відповідальності.

Стаття III засновує цей контур. Вона створює судову владу, перелічує сфери її дії, розподіляє первинну й апеляційну юрисдикцію, закріплює суд присяжних і місце кримінального розгляду, а також надзвичайно вузько визначає державну зраду та вимоги до її доведення. Подальша доктрина додає до цього тексту вимоги case or controversy, judicial review, standing, ripeness, mootness, межу консультативних висновків і правила остаточності рішень.

П’ята збірка приймає конфлікт зі статті IV і вперше створює об’єкт, здатний перейти до матеріального виконання. Вона також встановлює межу автоматизації: програма перевіряє походження record, зв’язки між фактами й висновками, ієрархію повноважень, область remedy та lineage перегляду. Зміст доказів, застосовність норми й юридичний висновок надходять через атрибутоване людське рішення. Судова машина отримує дисципліну трасування, зберігаючи людську відповідальність за зміст.

П’ята збірка

Зворотне складання Конституції дійшло до функції resolve():

П’ята функція отримує стан, створений усіма попередніми рівнями. Судова система прив’язана до чинного конституційного root зі статті V і федеративної топології зі статті IV. Вона приймає лише перелічені класи справ і спорів. Кожен суд має власний доведений мандат. Кожне рішення посилається на закритий record і чинні джерела. Кожен засіб відновлення отримує обмежену область та окремого виконавця.

У коді з’являються сім основних операцій:

Ця архітектура вперше змушує нас розрізнити чотири схожі події. Помилка WARDEN виявляє порушення інваріанта. Судовий finding встановлює факт на підставі record. Holding пов’язує встановлений факт із застосовною нормою. Remedy визначає спосіб відновлення конкретної області. Поєднання цих подій в одному всемогутньому компоненті зробило б систему коротшою й небезпечнішою; тиранія взагалі часто має чудовий DX, доки користувач не помічає, що роль користувача вже скасовано.

Судова влада як самостійний контур

Перший розділ статті III наділяє судовою владою один Верховний суд і нижчі суди, які засновує Конгрес. Судді Верховного й нижчих судів обіймають посади за умови good Behaviour та отримують винагороду, яку не можна зменшувати протягом перебування на посаді. Ці положення створюють інституційну незалежність рішення від поточного бажання сторони, яка контролює бюджет або виконання.

Програмна модель переводить їх у топологічні інваріанти. У системі існує рівно один компонент із типом supreme. Нижчий суд за статтею III потребує підтвердженої законодавчої підстави. Кожен активний суд має принаймні одного суддю із засвідченою комісією, tenure good-behaviour і захистом винагороди non-diminution. Щорічне поновлення повноважень або бюджетне право зменшувати оплату через зміст рішення блокує саме складання судового контуру.

Такий код не стверджує, що американський суддя є об’єктом із трьома полями. Він показує властивості, без яких незалежний resolver поступово стає методом компонента, що його викликає. Виконавча влада отримує зручний суд, законодавча — слухняного інтерпретатора, а система — церемонію перевірки замість окремого повноваження.

Призначення суддів пов’язане зі статтею II, а заснування нижчих судів і надання їм законодавчої юрисдикції — зі статтею I. Зворотний порядок серії вимагає тимчасово передати constituteJudiciary() вже засвідчені комісії та статутні grants. Наступні публікації пояснять їхнє походження й замінять тестові fixtures повноцінними результатами execute() та legislate().

WARDEN залишається зовнішнім випробувальним контуром. Він може підтвердити наявність одного Верховного суду, захист tenure, цілісність record і межі remedy. Суд має повноваження встановити юридично значущі факти й ухвалити рішення в конкретному спорі. Поділ зберігається навіть тоді, коли обидві операції технічно виражені JavaScript-функціями.

Спір починається з права бути розглянутим

Судова влада статті III поширюється на перелічені Cases і Controversies. Сучасна доктрина розвиває з цієї формули вимоги до конкретності спору. Федеральний суд розглядає протистояння сторін, у якому заявник показує фактичну шкоду, причинний зв’язок і здатність судового рішення усунути цю шкоду. Спір надходить до суду в належний час і зберігає актуальність. Абстрактне питання про правильне прочитання Конституції залишається поза межами такого розгляду.

Прототип виражає цей поріг через шість перевірок:

Кожне значення тут є результатом попередньо засвідченої юридичної та фактичної оцінки. Булеве поле не відкриває філософську істину про шкоду й причинність. Воно робить походження допуску спостережуваним для наступної операції. Реальна система потребуватиме окремих артефактів, заперечень, слухання та рішення щодо порогових питань.

Відсутність будь-якого елемента дає результат dismissed-without-merits. Він має самостійне значення. Суд повідомляє, що конкретна справа не пройшла шлюз судової влади, залишаючи зміст спірної норми відкритим для іншої належної справи. Тому програмна модель не записує відмову через standing як підтвердження законності дії відповідача.

Потенційне political question отримує окремий стан requires-justiciability-determination. WARDEN не може перетворити цю позначку на остаточне рішення. Суд має визначити, чи існує керований правовий стандарт, чи передано питання іншій гілці та яку частину спору все ж можна розв’язати судовим способом.

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

Дев’ять підстав і один компетентний форум

Стаття III перелічує дев’ять класів федеральної судової влади. Їх зручно подати як типізовані входи, хоча кожен тип має велику доктринальну історію:

Наявність категорії встановлює межу федеральної judicial power і ще не призначає конкретний суд. Конституція відносить до первинної юрисдикції Верховного суду справи, що стосуються послів, інших публічних міністрів і консулів, а також справи, у яких штат є стороною. Інші перелічені справи входять до апеляційної юрисдикції Верховного суду з exceptions і regulations Конгресу, передбаченими Конституцією. Федеральні закони створюють і розподіляють фактичну юрисдикцію нижчих судів; наприклад, 28 U.S.C. § 1251 робить спори між штатами частиною первинної та виключної юрисдикції Верховного суду.

Прототип зберігає grants у реєстрі судів. docketCase() перевіряє конституційну категорію, доведене первинне повноваження обраного суду та спеціальний маршрут міжштатного спору. Отримання petition не розширює компетенцію компонента. Поле courtId: "supreme" так само не перетворює звичайне апеляційне питання на справу первинної юрисдикції.

XI поправка потребує окремого version-aware gate. Її текст обмежує судову владу в певних позовах проти штату з боку громадян іншого штату або іноземної держави. Модель блокує прямий позов такого класу проти штату-учасника, який не дав згоди, і дозволяє явно засвідченій згоді пройти цей вузький прототипний поріг. Сучасна доктрина імунітету штатів, waivers, congressional abrogation та Ex parte Young значно складніша. П’ята збірка прямо позначає цю ділянку як скорочену модель.

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

Record відокремлює твердження від факту

Сторони входять у процес із несумісними твердженнями. Судове рішення спирається на факти, встановлені через застосовну процедуру. Між цими станами розташовані докази, правила допустимості, заперечення, stipulations і робота уповноваженого fact finder.

closeRecord() приймає evidence і findings. Кожен доказовий об’єкт має ідентифікатор, клас, стан authentication, стан admission і набір підтримуваних propositions. Кожен finding посилається на один або кілька допущених і засвідчених evidence IDs. Посилання на відсутній об’єкт, виключений доказ або неавтентичний документ блокує закриття record.

Ця модель навмисно не обчислює правдивість testimony та вагу доказу. Fact finder передає підсумковий finding із власним засвідченим повноваженням і бере на себе відповідальність за оцінку. Код підтверджує, що рішення згодом використовує саме закритий record і не створює нового факту всередині resolve().

Цей підхід особливо важливий під час роботи з LLM. Мовна модель може створити переконливе проміжне пояснення, якого ніколи не було в матеріалах справи. Без обов’язкового посилання на finding та evidence така фраза легко стає «встановленим фактом» лише тому, що добре виглядає в тексті. Держави історично вміли творити цю магію і без трансформерів; автоматизація лише обіцяє промисловий масштаб із приємним інтерфейсом.

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

resolve() створює пояснюване рішення

Центральна функція приймає judiciary, docket, закритий record, набір authorities і сформоване людиною decision. Вона перевіряє цілісність кожного входу та створює незмінний judgment.

Authority має тип, citation, operative status, засвідчене походження та місце в ієрархії. Конституція й поправки мають належати до поточного root. Федеральний статут потребує окремого pursuance determination, а договір — підтвердження укладення under the Authority of the United States. State law може залишатися в наборі як реально наявне джерело й водночас мати displacedBy із посиланням на верховну норму.

Holding містить п’ять обов’язкових частин:

Прототип блокує holding, який посилається на відсутній finding, вигаданий authority або витіснену локальну норму без включення контрольної верховної норми. Така перевірка виражає judicial review як operation усередині конкретної справи. Текст статті III прямо не містить розгорнутого алгоритму judicial review; історична й доктринальна лінія, міцно пов’язана з Marbury v. Madison, пояснює застосування Конституції судом у разі конфлікту норм.

Код водночас не обирає юридично «правильне» тлумачення за числовим rank. Rank захищає вже встановлену ієрархію джерел. Applicability, meaning і scope залишаються змістом holding, ухваленого судом. Конституційний текст, статут, precedent і факти можуть допускати кілька аргументованих комбінацій. Рішення набуває перевірюваної структури й надалі потребує відповідального автора.

У демонстраційній справі штат, що приймає, прагне замінити вихідний ефект грошового рішення позбавленням волі боржника. Стаття IV повертає requires-resolution із причиною effect-exceeds-or-differs-from-origin. Суд встановлює два факти: вихідний judgment дозволяє стягнення грошей, а receiving authority вимагає imprisonment. Holding застосовує статтю IV, 28 U.S.C. § 1738 і стан конфліктної локальної норми. Remedy обмежує виконання ефектом, який існував у вихідній юрисдикції.

{
  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 закінчується там, де починається виконання

Суд може надати або відхилити relief, закрити справу без розгляду merits, обмежити дію, зобов’язати виконати передбачену операцію, скасувати оскаржуваний стан або повернути справу для нової процедури. Реальний набір remedies залежить від юрисдикції, підстави позову та застосовного права. Прототип моделює загальний контракт відновлення.

Кожен coercive remedy містить target, operation, scope, executableBy, підтвердження redressability і перевірку найменшої достатньої області. Remedy, який не може виправити доведену шкоду, конфліктує з порогом standing. Remedy, що виходить за межі розглянутої справи, перетворює конкретне судове повноваження на загальну адміністративну владу.

resolve() самостійно не змінює федеративний runtime. Він повертає pending-separate-execution і адресу article-ii:execute. Суд визначає обов’язковий стан, а виконавчий контур обирає й застосовує дозволені матеріальні засоби. Наступна публікація перевірить, чи здатен президентський control plane сумлінно виконати judgment, зберегти trace, обмежити capability і повернути підтвердження результату.

Відмова в relief створює case-closed і no-coercive-remedy. Це також виконуваний стан у широкому розумінні: система знає, що примусової операції немає. Судовий компонент не отримує приводу «зробити хоч щось корисне» після відмови. Ініціатива дуже людська, особливо коли бюджет уже освоєно, однак capability model цінує нудну точність.

Перегляд створює lineage

Апеляція працює з наявним judgment. Вона перевіряє засвідчене й своєчасне notice, повноваження вищого суду та цілісність рішення. Результат отримує новий digest і parentJudgmentDigest; попередня редакція залишається в історії.

Модель розрізняє чотири результати:

Stay призупиняє виконання, зберігаючи judgment і маршрут перегляду. Remand повертає article-iii:resolve-on-remand і знімає попередній coercive remedy. Завершений Верховним судом перегляд отримує finalWithinArticleIII. Це поле позначає межу поточного прототипу й не описує всі реальні механізми rehearing, collateral review та наступних проваджень.

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

Остаточне опубліковане рішення може увійти до системи як precedent. publishPrecedent() вимагає authenticated publication, точне ratio, посилання на holdings і перелічену область обов’язковості. Повний текст judgment і застосовне ratio залишаються різними об’єктами. Специфікація stare decisis сформована подальшою доктриною, а реальна сила precedent залежить від рівня суду, предмета й відмінностей у фактах. Прототип пропонує інженерний формат зберігання та прямо відносить його до розвитку вихідного тексту 1787 року.

Кримінальний маршрут і межа судової ефективності

Стаття III вимагає суду присяжних для всіх злочинів, крім impeachment, і визначає місцем trial штат, де скоєно злочин. Для діяння поза межами будь-якого штату Конгрес визначає місце законом. validateCriminalTrial() перевіряє ці шлюзи й спрямовує impeachment до окремого маршруту статті I.

Модель свідомо не охоплює весь кримінальний процес. VI поправка розвиває право на speedy and public trial, impartial jury, notice, confrontation, compulsory process та assistance of counsel. Правила доказування, стандарти обвинувачення, sentencing і appellate review походять з інших конституційних положень, законів і доктрини. П’ята функція фіксує лише каркас, безпосередньо потрібний для програмної інтерпретації статті III.

Особливо виразним є розділ про державну зраду. Конституція обмежує treason двома теоріями: levying War та adhering to Enemies із наданням Aid and Comfort. Conviction потребує свідчень двох свідків про один і той самий overt Act або confession in open court. Конгрес визначає punishment, зберігаючи заборону corruption of blood і forfeiture поза межами життя засудженої особи.

screenTreasonCharge() перевіряє визначення та доказовий шлюз. Два свідчення про різні дії не утворюють потрібної пари. Дублювання одного witness ID також не створює двох свідків. Успішна перевірка повертає eligible-for-jury-determination і значення conviction: "not-determined-by-gateway". Питання винуватості належить trial, а WARDEN підтверджує лише допустимість входу.

Таке обмеження має самостійну архітектурну цінність. Обвинувачення в державній зраді зручне для влади саме своєю емоційною широтою: складний політичний конфлікт можна стиснути до ярлика, після чого coercive stack радісно зробить решту. Конституція перетворює ярлик на вузький тип із важким доказовим контрактом. Державна машина все ще може вбивати людей, однак їй принаймні заборонено приймати ентузіазм адміністратора за валідну схему даних.

Виконуваний судовий шар

Нижче наведено повний ESM-модуль п’ятої збірки. Він імпортує лише digest() зі статті IV і приймає сформовані попередніми публікаціями normativeRoot та federation. Код виконується в Node.js без зовнішніх залежностей.

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: сімдесят сценаріїв судової влади

WARDEN перевіряє сімдесят сценаріїв п’ятої збірки. Кожен тест оголошує джерело інваріанта: буквальне положення статті III, XI поправку, судову доктрину або інженерне правило «Конституції коду».

Головний негативний інваріант проходить через увесь корпус: WARDEN не створює finding, holding, remedy, guilt або punishment. Він може зупинити пошкоджений pipeline і показати місце порушення. Змістовне рішення залишається за заснованим судом і доказовим 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);
	},
);

Перевірка виконується командою:

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

Результат поточної редакції:

tests 70
pass 70
fail 0

Спільний запуск четвертої та п’ятої збірок підтверджує 112 сценаріїв: 42 федеративні й 70 судових. Інтеграційний тест створює справжній requires-resolution через recognizeInterstateArtifact() статті IV, а потім проводить його через docket, record і judgment статті III.

Що стаття III дає програмній архітектурі

П’ята збірка пропонує кілька переносних принципів.

Перший принцип вимагає конкретного конфлікту. Архітектурний resolver отримує сторони, порушений стан, причинний зв’язок і досяжний результат. Загальне питання без власника шкоди й без можливого remedy належить до проєктування політики, документації або законодавчого процесу.

Другий принцип пов’язує компетенцію з типом події. Компонент отримує перелічені jurisdiction heads та окремі grants. Вхідний пакет не розширює його владу. Така модель корисна для систем підтримки, арбітражу плагінів, policy engines і внутрішніх governance-процедур.

Третій принцип відокремлює record від reasoning. Докази отримують provenance і admission state, findings посилаються на докази, а holdings — на findings та authorities. LLM може допомагати будувати пояснення, перевіряти повноту посилань і виявляти конфлікт. Джерело факту й відповідальність за висновок залишаються видимими.

Четвертий принцип робить remedy окремим об’єктом. Він містить target, operation, scope, виконавця та зв’язок із доведеною шкодою. Рішення передається виконавчому компоненту й не отримує необмеженого прямого доступу до runtime.

П’ятий принцип зберігає перегляд як lineage. Affirm, reverse, vacate і remand створюють нові стани, зберігаючи вихідний judgment. Прецедент публікується як пов’язане ratio з явною областю, а не як містична властивість усього тексту рішення.

Шостий принцип посилює перевірки для політично небезпечних операцій. Що легше обвинувачення здатне обійти звичайну класифікацію, то вужчою має бути схема входу й дорожчим доказовий поріг. Стаття III показує це на treason із разючою інженерною ясністю.

Де закінчується п’ятий експеримент

Прототип зберігає суттєві межі.

Він моделює сучасний standing шістьма засвідченими ознаками й не відтворює всі винятки, спеціальні права, representational standing і відмінності між constitutional та prudential doctrines. Ripeness, mootness і political question зведено до спостережуваних шлюзів, хоча реальні спори щодо них самі потребують аргументації та рішення.

Реєстр юрисдикції використовує заздалегідь передані congressional grants. Він не охоплює removal, supplemental jurisdiction, abstention, sovereign immunity у всій сучасній формі, personal jurisdiction, venue statutes і складну межу між судами Article III та трибуналами Article I. XI поправку подано як вузький прямий gate зі згодою, тоді як сучасна доктрина значно багатша.

Authority rank захищає відому ієрархію й не встановлює meaning. Судове тлумачення, вибір застосовного права, standard of review та reconciliation прецедентів потребують людського юридичного судження. madeInPursuanceVerified також надходить ззовні; реальне питання відповідності статуту Конституції часто є самим предметом справи.

Record зберігає provenance і посилання, залишаючи поза моделлю credibility, burden of proof, evidentiary objections та процес формування jury verdict. Remedy обмежено загальним контрактом, який не відтворює відмінності між damages, injunction, declaratory relief, habeas, vacatur і багатьма спеціальними засобами.

Поле finalWithinArticleIII позначає зручну межу експерименту. Реальна остаточність залежить від рівня суду, часу, rehearing, collateral proceedings і характеру рішення. Прецедентна сила також походить із доктрини та інституційної практики, а не з одного прапорця.

Головна межа стосується виконання. Judgment може визначити допустимий стан та обов’язкову дію, однак зміна матеріального світу потребує людей, установ, грошей, доступу й іноді примусу. Наступна стаття передасть remedy президентському control plane. Там з’ясується, чи здатен виконавець дотриматися judgment, який обмежує саме його свободу дій. Такий unit test зазвичай викликає у влади раптовий інтерес до «гнучкого тлумачення вимог».

Висновок

Стаття III перетворює спільну нормативну архітектуру на механізм розв’язання конкретних конфліктів. Вона засновує незалежний контур судової влади, обмежує його переліченими справами й спорами, маршрутизує первинну та апеляційну юрисдикцію, вимагає спеціальної кримінальної процедури й захищає обвинувачення в державній зраді від політично зручної розпливчастості.

Програмна інтерпретація додає простежуваний record, типізовані authorities, holdings із посиланнями на факти й норми, bounded remedy та незмінну lineage перегляду. Модель проходить 70 сценаріїв WARDEN і успішно приймає нерозв’язаний стан статті IV. Вона також підтверджує вихідну гіпотезу серії: значну частину конституційної архітектури можна виразити як виконувані контракти, зберігаючи змістові рішення за людьми й установами з доведеним повноваженням.

Після п’ятої збірки Америка вміє запускатися, визначати довірену редакцію, оновлювати ядро, з’єднувати автономні штати й розв’язувати конфлікти між ними. Judgment уже існує. Тепер хтось має виконати його, застосувати допустимі засоби й залишити перевірюваний слід.

Наступна функція — execute().

Продовжити дослідження з ШІ

Сайт формує цей розділ із незалежного набору питань constitution-runtime.article-iii.resolve, збереженого в супровідному каталозі constitution-runtime-05-article-iii-questions.yaml. Кожен prompt самостійно визначає свій предмет статті III, конституційне або доктринальне джерело, об’єкт прототипу та межу судового розгляду, тому може працювати поза лінійною послідовністю статті без втрати контексту.

Рекомендований маршрут: незалежний суд → справа або спір → юрисдикція → доказовий record → judicial review → обмежений remedy → апеляція і precedent → кримінальні гарантії → WARDEN → межі. Двомовний каталог містить контракт відповіді ШІ, шістдесят самостійних prompts, умови відкриття гілок, посилання на код і візуальні матеріали та навігацію повернення.

Відомості про публікацію

Автори: Sam Starling, Oksana Dubinetska
Контекст проєкту: Zhovten Games / IRONCREED
Повне дослідницьке джерело: «Конституція коду» — DOI 10.5281/zenodo.21894242
Репозиторій дослідження: FOP-Oksana-Dubinetska/code-constitution
Історичні, юридичні та технічні матеріали: текст Конституції США; огляд статті III; Judicial Vesting Clause; захист незалежності федеральних суддів; Cases or Controversies; консультативні висновки; standing; тест Lujan; ripeness; mootness; Marbury v. Madison і judicial review; первинна юрисдикція Верховного суду; 28 U.S.C. § 1251; XI поправка; історія Treason Clause; levying war; aid and comfort; остаточність рішень судів Article III
Пов’язані публікації: «Підключити Америку: як стаття VII запускає республіку»; «Чому довіряє Америка: як стаття VI збирає верховний порядок»; «Оновити Америку: як стаття V змінює конституційне ядро»; «Зв’язати Америку: як стаття IV перетворює штати на федеративну мережу»
Наступна публікація: стаття II — у розробці
Редакція публікації: 0.2 · 13 серпня 2026 року