Зв’язати Америку: як стаття IV перетворює штати на федеративну мережу

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

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

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

Карта вже світиться

У нашому проходженні Death Stranding підключення чергового вузла до хіральної мережі змінювало всю область, починаючи з кольору карти. На ній з’являлися сліди чужої роботи: мости, дороги, драбини, попередження й маршрути інших гравців. Об’єкт, побудований кимось в іншому проходженні, ставав фактом нашого оточення. Ми могли скористатися ним, посилити його, проігнорувати або виявити, що чужа драбина веде у прірву з тією впевненою інтонацією, яку зазвичай мають лише інфраструктура та державні реєстри.

Таке з’єднання дає вдалий вхід до статті IV. Попередні частини циклу вже створили спільний порядок. Стаття VII запустила Конституцію між штатами, що її ратифікували. Стаття VI встановила канонічний корпус і корінь довіри. Стаття V дозволила цьому корпусу оновлюватися. Після третьої збірки карта існує, редакція відома, походження повноваження доведено. Наступна проблема виникає між вузлами.

Штат може ухвалити закон, зареєструвати шлюб, видати свідоцтво, постановити судове рішення, висунути обвинувачення, встановити професійну вимогу або звернутися по федеральний захист. Інший штат зберігає власні органи, право та процедури. Федерація працює, коли кордон між ними залишається водночас реальним і прохідним. Повне злиття знищило б автономію. Повна ізоляція перетворила б Союз на колекцію сусідніх production-середовищ, кожне з яких вважає чужий JSON політичною заявою.

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

У програмній формі цей шар стає federate(). Функція створює реєстр автономних юрисдикцій під одним чинним root, а пов’язані операції визначають, які події можуть перетинати кордон, якого ефекту вони набувають і де потрібна зупинка для вирішення спору.

Четверта збірка

Зворотний маршрут циклу вперше виходить з історії одного спільного артефакту в простір кількох локальних станів.

Четверта збірка приймає normativeRoot, повернений моделлю статті V, і додає вісім елементів:

1. реєстр штатів із власними конституційними digest;
2. реєстр територій як окремої області федерального керування;
3. протокол випуску міжюрисдикційного артефакту;
4. протокол визнання з перевіркою походження, цілісності, редакції, компетенції та остаточності;
5. перевірку рівного становища громадянина іншого штату;
6. контрольоване передання кримінальної відповідальності між штатами;
7. транзакцію приєднання нового штату та зміни топології;
8. обмежену модель федеральної захисної функції.

Результат стає першим справді розподіленим об’єктом циклу. У ньому присутні кілька власників стану, кілька джерел похідних рішень, повідомлення між вузлами, правила сумісності, зміна складу мережі й окремий маршрут для спорів. Головний root залишається спільним, а локальні конституції та органи зберігають статус самостійних джерел замість перетворення на кеш федеральної адміністрації.

Стаття горизонтальних зв’язків

Чотири розділи статті IV виконують різні функції, які варто зберігати окремими.

Ця карта відразу показує межу простої аналогії з мікросервісами. Звичайний сервіс не має власної конституції, громадян і території, а його API-контракт не гарантується політичною системою, здатною застосовувати примус. Технічна модель залишається корисною, коли описує походження, кордон, контракт і перехід. Вона стає декоративною, коли штат отримує назву service-west-1, а автор оголошує федералізм успішно задеплоєним.

Full Faith and Credit: чуже рішення стає місцевим фактом

Перший розділ статті IV вимагає від кожного штату надавати повну довіру публічним актам, офіційним записам і судовим провадженням інших штатів. Він також уповноважує Конгрес загальними законами встановлювати спосіб доказування таких артефактів та їхній ефект. Чинна реалізація цього повноваження включає 28 U.S.C. § 1738, що регулює засвідчення й вимагає надавати належно підтвердженим матеріалам той самий full faith and credit, який вони мають у судах штату походження.

Слово «визнання» тут потребує точності. Воно встановлює нормативне значення результату іншої юрисдикції, а виконання утворює наступну самостійну стадію.

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

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

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

flowchart TB
    A["Акт, запис або рішення штату походження"] --> B["Походження, цілісність і редакція"]
    B --> C{"Компетенцію та чинність підтверджено?"}
    C -- "Ні" --> D["Призупинення й передання до статті III"]
    C -- "Так" --> E{"Клас артефакту"}
    E --> F["Судове рішення: та сама дія, що у джерелі"]
    E --> G["Публічний акт: аналіз застосовного права"]
    E --> H["Офіційний запис: визначене доказове значення"]

Визнання починається раніше за виконання

У «Конституції коду» горизонтальну сумісність розвинено через шість перевірок: provenance, integrity, revision, competence, finality і contemplated effect. Ця послідовність розширює буквальний текст статті IV інженерним контрактом, який дозволяє автоматизувати визнання без автоматизації довірливості.

issueInterstateArtifact() пов’язує кожен артефакт із root федерації, штатом походження, класом, редакцією, органом, предметною компетенцією, станом та ефектом у вихідній юрисдикції. Digest підтверджує точність серіалізованого вмісту. recognizeInterstateArtifact() повторно обчислює digest і розглядає докази автентичності, редакції та компетенції. Один рядок authenticated: true залишається результатом зовнішньої перевірки; код не зображає нотаріуса за допомогою булевого значення.

Сумісність із попередніми редакціями root задається явно. Поправка не повинна автоматично анулювати кожне старе свідоцтво й судове рішення. compatibleArtifactRoots містить попередні редакції, артефакти яких переживають перехід відповідно до перевіреного плану статті V. Невідома редакція переводить операцію в requires-resolution. Таке рішення запобігає двом симетричним помилкам: безмежній довірі до будь-якого legacy й урочистому знищенню всієї пам’яті після кожного оновлення.

У разі провалу перевірки модуль призупиняє виконання, зберігає зворотність і передає питання майбутній функції resolve() зі статті III. WARDEN не отримує судового мандата. Він може довести, що програма зупинилася на позначеній межі; право вирішити спір з’явиться лише в наступній збірці.

Громадянин перетинає кордон

Перше речення розділу IV.2 надає громадянам кожного штату привілеї та імунітети громадян в інших штатах. Ця формула не уніфікує все місцеве право й не робить резидентство юридично невидимим. Вона захищає фундаментальні види міжштатної діяльності від необґрунтованої дискримінації за ознакою громадянства іншого штату.

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

Прототип свідомо використовує вузький перелік уже класифікованих областей: ведення звичайної професійної діяльності, доступ до судів і володіння чи передання майна. Невідома діяльність отримує requires-legal-classification. Корпорація отримує outside-article-iv-privileges-model, оскільки ця конкретна клауза говорить про громадян, а корпорації не вважаються громадянами для її цілей. Повний режим рівного захисту, права на переміщення й федерального громадянства потребує також XIV поправки та іншої доктрини; стаття IV не повинна поглинати наступні рівні одним зручним об’єктом person.

flowchart TB
    A["Громадянин штату A діє у штаті B"] --> B{"Діяльність захищена статтею IV?"}
    B -- "Потрібна класифікація" --> C["Передання до компетентного розгляду"]
    B -- "Так" --> D{"Умови рівні з резидентами?"}
    D -- "Так" --> E["Рівне становище"]
    D -- "Ні" --> F{"Істотна причина і тісний зв’язок доведені?"}
    F -- "Так" --> G["Обґрунтоване розрізнення"]
    F -- "Ні" --> H["Усунення умови або оскарження"]

Передання відповідальності без зникнення кордону

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

evaluateInterstateTransfer() перевіряє автентичність вимоги виконавчої влади, наявність підтвердженого документа про обвинувачення, збіг особи й установлений статус утікача від правосуддя. Успішний результат передає операцію виконавчому контуру, який повністю опише стаття II. Провал перевірки передає питання статті III. Модуль визначає допустимість маршруту, а не винуватість чи зміст кримінального процесу.

Такий порядок показує відмінність між визнанням і переданням відповідальності. Штат, що приймає, не оголошує обвинувачення правдивим. Він визнає встановлений клас запиту, перевіряє потрібні умови й повертає людину до юрисдикції, де компетентний суд розгляне обвинувачення. Федеративний кордон зберігається, проте відмовляється ставати кнопкою очищення call stack.

Історичний пакет, який чинна редакція зобов’язана відхилити

Третє речення первинного розділу IV.2 вимагало повертати людей, «зобов’язаних до служби або праці», які втекли до іншого штату. Юридичний евфемізм описував рабовласницьку систему. Федеративна сумісність включала обов’язок вільного штату сприяти відновленню влади поневолювача над людиною.

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

XIII поправка заборонила рабство й підневільний стан у Сполучених Штатах, крім покарання за злочин після належного засудження. Національні архіви прямо зазначають, що відповідну частину статті IV замінила ця поправка; історія й текст XIII поправки фіксують ратифікацію 6 грудня 1865 року. Constitution Annotated називає Fugitive Slave Clause фактично анульованою скасуванням рабства.

Тому четвертий модуль зберігає рядок в історичному корпусі й відмовляється його виконувати. CURRENT_CLAUSE_STATUS["IV.2.3"] утримує походження, установлює operative: false і пов’язує статус із XIII поправкою. Кожен запит fugitive-labor отримує rejected. Ця перевірка вперше практично використовує результат попередньої публікації: оновлений root змінює поведінку старішого розділу.

Legacy залишається доступним для аудиту й недоступним для виконання. Такий стан точніший за видалення, яке стирає походження, і безпечніший за «зворотну сумісність», що іноді означає готовність воскресити варварство заради зеленого pipeline.

Нові вузли змінюють топологію

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

admitState() пов’язує кандидата з чинним root, власною конституцією, датою, способом формування й переліком заторкнутих штатів. Конгрес підтверджує один digest кандидата. Кожна заторкнута легіслатура підтверджує ту саму редакцію. Дублікат наявного штату, невідповідний digest, відсутність акта Конгресу або необхідної локальної згоди залишають попередню топологію без змін.

Після успішного приєднання новий штат отримує становище equal-footing. Рівне становище нових штатів розвинулося як конституційна доктрина: Constitution Annotated пояснює, що новий штат входить із тими самими суверенними повноваженнями та юрисдикцією, які мають решта штатів. Конгрес може встановити попередні умови прийняття, проте не може залишити нового учасника в постійному режимі member-lite, якщо таке обмеження порушує рівність штатів.

flowchart TB
    A["Кандидат у новий штат"] --> B["Точна редакція і digest приєднання"]
    B --> C{"Акт Конгресу підтверджено?"}
    C -- "Ні" --> D["Чинна топологія зберігається"]
    C -- "Так" --> E{"Змінюються кордони наявних штатів?"}
    E -- "Ні" --> H["Прийняття до Союзу"]
    E -- "Так" --> F{"Є згода всіх заторкнутих легіслатур?"}
    F -- "Ні" --> D
    F -- "Так" --> H
    H --> I["Рівне становище нового штату"]

Стаття IV описує вхід і певні зміни кордонів. Вона не містить передбаченого протоколу одностороннього виходу штату із Союзу. «Конституція коду» включає загальне питання про exit для програмних федерацій, однак американська адаптація не отримує leaveUnion() із тексту статті IV. Програма зберігає відсутність операції замість генерування зручного шляху за аналогією з видаленням worker node.

Територія становить окремий клас області

Друга клауза розділу IV.3 надає Конгресу повноваження розпоряджатися територією та іншим майном Сполучених Штатів і встановлювати необхідні правила. Заключна застережна клауза зберігає претензії Сполучених Штатів та окремих штатів від несприятливого тлумачення самої Конституції. Огляд Property Clause і матеріали про повноваження Конгресу показують широту цього федерального предмета.

Програмна модель зберігає території окремо від штатів. regulateFederalTerritory() потребує підтвердженого акта Конгресу, відповідного root і відомої території. Результат отримує claimsPreserved: true, оскільки рішення про керування спільною областю не має приховано вирішувати окремий спір про право власності. Такий спір знову належить статті III.

Відмінність штату від території істотна. Обидва об’єкти можуть мати населення, адміністрацію, дані й інфраструктуру. Їхня технічна насиченість не створює однакової юрисдикційної категорії. У «Конституції коду» окремий репозиторій, мова, команда чи deployment також самі собою не породжують автономії; юрисдикція виникає через визнаний розподіл повноважень, стану, обов’язків і способів вирішення конфлікту.

Гарантія системи й тимчасовий захист

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

Вислів domestic Violence у тексті XVIII століття означає внутрішнє повстання або протиправну силу всередині політичної спільноти. Сучасне словосполучення «домашнє насильство» позначає насильство в сім’ї й тут створює хибний переклад. Історичний огляд Guarantee Clause прямо відзначає архаїчне значення терміна.

Модель розрізняє три маршрути. Підтверджене вторгнення створює федеральний захисний обов’язок без попередньої заяви штату. Внутрішнє насильство потребує засвідченої заяви легіслатури; виконавча влада штату отримує резервний маршрут лише за неможливості скликати легіслатуру. Спір щодо республіканської форми отримує requires-constitutional-determination, оскільки зміст гарантії та межі судового розгляду розвинулися в політичній і судовій практиці. Булеве поле republican: true може прикрасити об’єкт, але ще не навчилося засновувати республіку.

Обмеження плану захисту походять із «Конституції коду», а не з буквального переліку статті IV. Прототип вимагає необхідного обсягу, найменших привілеїв, дати перегляду, умови завершення й заборони постійного передання влади. Федеральний захист отримує тимчасовий capability і не стає прихованим способом привласнити локальну юрисдикцію.

flowchart TB
    A["Загроза штату"] --> B{"Тип загрози"}
    B --> C["Вторгнення: підтверджений факт"]
    B --> D["Внутрішнє насильство: заява легіслатури"]
    D --> E["Резерв: виконавча влада, якщо легіслатуру неможливо скликати"]
    C --> F["Обмежений план захисту"]
    E --> F
    F --> G{"Мету, обсяг, строк і вихід визначено?"}
    G -- "Так" --> H["Тимчасова федеральна функція"]
    G -- "Ні" --> I["Відмова або перегляд"]

Виконувана федерація

Модуль написано як ESM-файл для Node.js із використанням лише стандартної бібліотеки. Його можна зберегти під назвою article-iv.mjs. Він сумісний з об’єктом constitutionalRoot, який повертала функція attestAndIntegrate() у третій публікації: обов’язковими залишаються constitutionId, digest і стан in-force, а lineage переноситься до знімка федерації.

Центральна функція federate() не виконує всі операції самостійно. Вона засновує перевірюване середовище й повертає реєстри, topology digest і чотири протоколи. Решта експортованих функцій змінюють або перевіряють конкретний клас відносин. Такий поділ відображає саму статтю IV: визнання рішення, становище громадянина, видача обвинуваченого, прийняття штату й захисна інтервенція мають різні джерела, дані та наслідки.

import { createHash } from 'node:crypto';

export const ARTICLE_IV = deepFreeze({
	id: 'U.S.Const.art.IV',
	rules: {
		fullFaith:
			'IV.1: states give full faith and credit to the public acts, records, and judicial proceedings of every other state',
		proofAndEffect:
			'IV.1: Congress may prescribe by general laws how interstate acts, records, and proceedings are proved and what effect they have',
		privileges:
			'IV.2.1: citizens of each state receive the privileges and immunities of citizens in the several states',
		extradition:
			"IV.2.2: a person charged with crime and found in another state is delivered on the demanding executive authority's request",
		fugitiveLaborHistorical:
			'IV.2.3: the historical fugitive-labor clause was superseded by Amendment XIII',
		admission:
			'IV.3.1: Congress may admit new states; specified boundary changes also require consent of the legislatures concerned',
		property:
			'IV.3.2: Congress may regulate United States territory and property without prejudicing preserved claims',
		guarantee:
			'IV.4: the United States guarantees republican government and protects states against invasion and qualifying domestic violence',
	},
	doctrine: {
		judgmentEffect:
			'A valid final judgment ordinarily receives the same effect in the receiving forum as in the rendering state',
		equalFooting:
			'A newly admitted state enters the Union on equal footing with the existing states',
		privilegesReview:
			'Discrimination concerning a protected interstate privilege requires a substantial reason and a close relationship to that reason',
	},
	engineering: {
		recognitionPipeline:
			'Constitution of Code IV.2: verify provenance, integrity, revision, competence, finality, and contemplated effect before execution',
		safeDispute:
			'Constitution of Code IV.2: suspend execution and preserve reversibility while a recognition dispute awaits Article III resolution',
		protectiveIntervention:
			'Constitution of Code IV.6: temporary protection is limited by purpose, scope, duration, audit, and an exit condition',
	},
});

export const CURRENT_CLAUSE_STATUS = deepFreeze({
	'IV.2.3': {
		operative: false,
		status: 'superseded-by-amendment-xiii',
		effectiveAt: '1865-12-06',
	},
});

export const INTERSTATE_ARTIFACT_CLASSES = Object.freeze([
	'public-act',
	'public-record',
	'final-judgment',
]);

export const PROTECTED_INTERSTATE_ACTIVITIES = Object.freeze([
	'pursue-common-calling',
	'access-courts',
	'own-or-transfer-property',
]);

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 canonicalJson(value) {
	if (Array.isArray(value)) {
		return `[${value.map(canonicalJson).join(',')}]`;
	}

	if (value && typeof value === 'object') {
		const body = Object.keys(value)
			.sort()
			.map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`)
			.join(',');

		return `{${body}}`;
	}

	return JSON.stringify(value);
}

export function digest(value) {
	return `sha256:${createHash('sha256').update(canonicalJson(value)).digest('hex')}`;
}

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 assertKnownState(federation, state, label) {
	requireNonEmptyString(state, label);

	if (!federation.states.some((entry) => entry.id === state)) {
		throw new TypeError(`Unknown member state: ${state}`);
	}
}

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])],
	};
}

export function federate({
	normativeRoot,
	states,
	territories = [],
	compatibleArtifactRoots = [],
}) {
	assertNormativeRoot(normativeRoot);
	requireArray(states, 'states');
	requireArray(territories, 'territories');
	requireUniqueStrings(compatibleArtifactRoots, 'compatibleArtifactRoots');

	const stateIds = states.map((state) => state.id);
	requireUniqueStrings(stateIds, 'state ids');

	const normalizedStates = states.map((state) => {
		requireNonEmptyString(state.constitutionDigest, `${state.id}.constitutionDigest`);
		requireNonEmptyString(state.admittedAt, `${state.id}.admittedAt`);
		requireBoolean(state.republicanFormVerified, `${state.id}.republicanFormVerified`);

		return {
			id: state.id,
			constitutionDigest: state.constitutionDigest,
			admittedAt: state.admittedAt,
			republicanFormVerified: state.republicanFormVerified,
			standing: 'member-state',
		};
	});

	const territoryIds = territories.map((territory) => territory.id);
	requireUniqueStrings(territoryIds, 'territory ids');

	const normalizedTerritories = territories.map((territory) => ({
		id: territory.id,
		ruleRevision: territory.ruleRevision,
		status: 'federal-territory',
	}));
	const topology = {
		rootDigest: normativeRoot.digest,
		stateIds,
		territoryIds,
	};

	return deepFreeze({
		federationId: `federation:${digest(topology).slice(7, 23)}`,
		normativeRoot: snapshotRoot(normativeRoot),
		states: normalizedStates,
		territories: normalizedTerritories,
		topologyDigest: digest(topology),
		compatibleArtifactRoots: [
			normativeRoot.digest,
			...compatibleArtifactRoots.filter((entry) => entry !== normativeRoot.digest),
		],
		protocols: {
			recognition: 'article-iv-section-1',
			mobility: 'article-iv-section-2',
			membership: 'article-iv-section-3',
			protection: 'article-iv-section-4',
		},
		trace: [
			ARTICLE_IV.rules.fullFaith,
			ARTICLE_IV.rules.privileges,
			ARTICLE_IV.rules.admission,
			ARTICLE_IV.rules.guarantee,
		],
	});
}

export function issueInterstateArtifact({
	federation,
	issuerState,
	id,
	artifactClass,
	revision,
	issuedAt,
	issuingAuthority,
	authorityScope,
	final = false,
	stayed = false,
	payload,
	effectAtOrigin,
}) {
	assertKnownState(federation, issuerState, 'issuerState');
	requireNonEmptyString(id, 'id');
	requireNonEmptyString(revision, 'revision');
	requireNonEmptyString(issuedAt, 'issuedAt');
	requireNonEmptyString(issuingAuthority, 'issuingAuthority');
	requireNonEmptyString(authorityScope, 'authorityScope');
	requireNonEmptyString(effectAtOrigin, 'effectAtOrigin');
	requireBoolean(final, 'final');
	requireBoolean(stayed, 'stayed');

	if (!INTERSTATE_ARTIFACT_CLASSES.includes(artifactClass)) {
		throw new TypeError('Unsupported interstate artifact class');
	}

	const content = interstateArtifactContent({
		federationRootDigest: federation.normativeRoot.digest,
		issuerState,
		id,
		artifactClass,
		revision,
		issuedAt,
		issuingAuthority,
		authorityScope,
		final,
		stayed,
		payload,
		effectAtOrigin,
	});

	return deepFreeze({
		...content,
		digest: digest(content),
		trace: [ARTICLE_IV.rules.fullFaith],
	});
}

function interstateArtifactContent(artifact) {
	return {
		federationRootDigest: artifact.federationRootDigest,
		issuerState: artifact.issuerState,
		id: artifact.id,
		artifactClass: artifact.artifactClass,
		revision: artifact.revision,
		issuedAt: artifact.issuedAt,
		issuingAuthority: artifact.issuingAuthority,
		authorityScope: artifact.authorityScope,
		final: artifact.final,
		stayed: artifact.stayed,
		payload: artifact.payload,
		effectAtOrigin: artifact.effectAtOrigin,
	};
}

function failedRecognitionChecks({ artifact, proof, requestedEffect }) {
	const failures = [];

	if (proof.authenticated !== true) failures.push('authentication');
	if (
		proof.integrityDigest !== artifact.digest ||
		artifact.digest !== digest(interstateArtifactContent(artifact))
	) {
		failures.push('integrity');
	}
	if (proof.revisionVerified !== true) failures.push('revision');
	if (proof.originCompetenceVerified !== true) failures.push('competence');
	if (artifact.stayed === true) failures.push('stayed-at-origin');

	if (artifact.artifactClass === 'final-judgment' && artifact.final !== true) {
		failures.push('finality');
	}

	if (artifact.artifactClass === 'final-judgment' && requestedEffect !== artifact.effectAtOrigin) {
		failures.push('effect-exceeds-or-differs-from-origin');
	}

	return failures;
}

export function recognizeInterstateArtifact({
	federation,
	receivingState,
	artifact,
	proof,
	requestedEffect,
	meritsReviewRequested = false,
}) {
	assertKnownState(federation, receivingState, 'receivingState');
	assertKnownState(federation, artifact.issuerState, 'artifact.issuerState');
	requireNonEmptyString(requestedEffect, 'requestedEffect');
	requireBoolean(meritsReviewRequested, 'meritsReviewRequested');

	if (!federation.compatibleArtifactRoots.includes(artifact.federationRootDigest)) {
		return deepFreeze({
			status: 'requires-resolution',
			recognized: false,
			execution: 'suspended',
			failedChecks: ['constitutional-revision'],
			handoff: 'article-iii:resolve',
			trace: [ARTICLE_IV.rules.fullFaith, ARTICLE_IV.engineering.safeDispute],
		});
	}

	const failedChecks = failedRecognitionChecks({
		artifact,
		proof,
		requestedEffect,
	});

	if (failedChecks.length > 0) {
		return deepFreeze({
			status: 'requires-resolution',
			recognized: false,
			execution: 'suspended',
			failedChecks,
			handoff: 'article-iii:resolve',
			trace: [
				ARTICLE_IV.rules.fullFaith,
				ARTICLE_IV.rules.proofAndEffect,
				ARTICLE_IV.engineering.safeDispute,
			],
		});
	}

	if (artifact.artifactClass === 'public-act') {
		return deepFreeze({
			status: 'recognized',
			recognized: true,
			execution: 'requires-choice-of-law-and-local-operation',
			effect: 'act-exists-and-enters-applicable-law-analysis',
			meritsReview: 'not-applicable',
			trace: [ARTICLE_IV.rules.fullFaith, ARTICLE_IV.rules.proofAndEffect],
		});
	}

	if (artifact.artifactClass === 'public-record') {
		return deepFreeze({
			status: 'recognized',
			recognized: true,
			execution: 'record-available-for-defined-use',
			effect: requestedEffect,
			meritsReview: 'not-applicable',
			trace: [ARTICLE_IV.rules.fullFaith, ARTICLE_IV.rules.proofAndEffect],
		});
	}

	return deepFreeze({
		status: meritsReviewRequested ? 'recognized-with-merits-review-denied' : 'recognized',
		recognized: true,
		execution: 'same-effect-as-origin',
		effect: artifact.effectAtOrigin,
		meritsReview: meritsReviewRequested ? 'denied-by-recognition-protocol' : 'not-requested',
		trace: [ARTICLE_IV.rules.fullFaith, ARTICLE_IV.doctrine.judgmentEffect],
	});
}

export function evaluateInterstateStanding({
	federation,
	citizenState,
	hostState,
	personKind = 'natural-person',
	activity,
	residentCondition,
	visitorCondition,
	classification,
}) {
	assertKnownState(federation, citizenState, 'citizenState');
	assertKnownState(federation, hostState, 'hostState');
	requireNonEmptyString(activity, 'activity');

	if (personKind !== 'natural-person') {
		return deepFreeze({
			status: 'outside-article-iv-privileges-model',
			protected: false,
			reason: 'clause-applies-to-citizens-not-corporations',
			trace: [ARTICLE_IV.rules.privileges],
		});
	}

	if (!PROTECTED_INTERSTATE_ACTIVITIES.includes(activity)) {
		return deepFreeze({
			status: 'requires-legal-classification',
			protected: null,
			reason: 'activity-not-classified-by-prototype',
			handoff: 'article-iii:resolve',
			trace: [ARTICLE_IV.rules.privileges],
		});
	}

	if (canonicalJson(residentCondition) === canonicalJson(visitorCondition)) {
		return deepFreeze({
			status: 'equal-standing',
			protected: true,
			discrimination: false,
			trace: [ARTICLE_IV.rules.privileges],
		});
	}

	const substantialReason = classification?.substantialReasonVerified === true;
	const closeRelationship = classification?.closeRelationshipToReasonVerified === true;

	return deepFreeze({
		status:
			substantialReason && closeRelationship
				? 'justified-distinction'
				: 'unjustified-discrimination',
		protected: true,
		discrimination: true,
		substantialReason,
		closeRelationship,
		remedy:
			substantialReason && closeRelationship
				? 'publish-and-apply-consistently'
				: 'remove-condition-or-submit-to-article-iii-review',
		trace: [ARTICLE_IV.rules.privileges, ARTICLE_IV.doctrine.privilegesReview],
	});
}

export function evaluateInterstateTransfer({ federation, request }) {
	if (request.kind === 'fugitive-labor') {
		return deepFreeze({
			status: 'rejected',
			executable: false,
			reason: CURRENT_CLAUSE_STATUS['IV.2.3'].status,
			clauseStatus: CURRENT_CLAUSE_STATUS['IV.2.3'],
			trace: [ARTICLE_IV.rules.fugitiveLaborHistorical],
		});
	}

	if (request.kind !== 'criminal-rendition') {
		throw new TypeError('Unsupported interstate transfer request');
	}

	assertKnownState(federation, request.demandingState, 'demandingState');
	assertKnownState(federation, request.asylumState, 'asylumState');
	const failedChecks = [];

	if (request.executiveDemandAuthenticated !== true) {
		failedChecks.push('executive-demand');
	}

	if (request.chargeDocumentVerified !== true) {
		failedChecks.push('charge-document');
	}

	if (request.identityMatched !== true) failedChecks.push('identity');
	if (request.fugitiveStatusVerified !== true) failedChecks.push('fugitive-status');

	return deepFreeze({
		status: failedChecks.length === 0 ? 'eligible-for-rendition' : 'requires-resolution',
		executable: failedChecks.length === 0,
		failedChecks,
		handoff: failedChecks.length === 0 ? 'executive-transfer' : 'article-iii:resolve',
		trace: [ARTICLE_IV.rules.extradition],
	});
}

function authenticatedConsents(consents, candidateDigest) {
	const accepted = new Set();

	for (const consent of consents) {
		if (
			consent.source === 'state-legislature' &&
			consent.authenticated === true &&
			consent.candidateDigest === candidateDigest &&
			consent.approved === true
		) {
			accepted.add(consent.state);
		}
	}

	return accepted;
}

export function admitState({
	federation,
	candidate,
	congressionalAct,
	affectedStateConsents = [],
}) {
	requireNonEmptyString(candidate.id, 'candidate.id');
	requireNonEmptyString(candidate.constitutionDigest, 'candidate.constitutionDigest');
	requireNonEmptyString(candidate.admissionDate, 'candidate.admissionDate');
	requireArray(candidate.affectedStates, 'candidate.affectedStates');
	requireUniqueStrings(candidate.affectedStates, 'candidate.affectedStates');

	if (federation.states.some((state) => state.id === candidate.id)) {
		return deepFreeze({
			status: 'rejected',
			reason: 'state-already-member',
			federation,
			trace: [ARTICLE_IV.rules.admission],
		});
	}

	const candidateContent = {
		id: candidate.id,
		constitutionDigest: candidate.constitutionDigest,
		admissionDate: candidate.admissionDate,
		formation: candidate.formation,
		affectedStates: candidate.affectedStates,
		rootDigest: federation.normativeRoot.digest,
	};
	const candidateDigest = digest(candidateContent);

	const congressApproved =
		congressionalAct?.authenticated === true &&
		congressionalAct?.approved === true &&
		congressionalAct?.candidateDigest === candidateDigest &&
		congressionalAct?.rootDigest === federation.normativeRoot.digest;

	if (!congressApproved) {
		return deepFreeze({
			status: 'rejected',
			reason: 'congressional-admission-not-proved',
			candidateDigest,
			federation,
			trace: [ARTICLE_IV.rules.admission],
		});
	}

	const consents = authenticatedConsents(affectedStateConsents, candidateDigest);
	const missingConsentFrom = candidate.affectedStates.filter((state) => !consents.has(state));

	if (missingConsentFrom.length > 0) {
		return deepFreeze({
			status: 'rejected',
			reason: 'affected-state-consent-missing',
			candidateDigest,
			missingConsentFrom,
			federation,
			trace: [ARTICLE_IV.rules.admission],
		});
	}

	const states = [
		...federation.states,
		{
			id: candidate.id,
			constitutionDigest: candidate.constitutionDigest,
			admittedAt: candidate.admissionDate,
			republicanFormVerified: candidate.republicanFormVerified === true,
			standing: 'member-state',
			admissionDigest: candidateDigest,
			equalFooting: true,
		},
	];
	const topology = {
		rootDigest: federation.normativeRoot.digest,
		stateIds: states.map((state) => state.id),
		territoryIds: federation.territories.map((territory) => territory.id),
	};
	const nextFederation = deepFreeze({
		...federation,
		states,
		topologyDigest: digest(topology),
		previousTopologyDigest: federation.topologyDigest,
	});

	return deepFreeze({
		status: 'admitted',
		candidateDigest,
		standing: 'equal-footing',
		federation: nextFederation,
		trace: [ARTICLE_IV.rules.admission, ARTICLE_IV.doctrine.equalFooting],
	});
}

export function regulateFederalTerritory({ federation, rule }) {
	requireNonEmptyString(rule.territory, 'rule.territory');

	if (!federation.territories.some((entry) => entry.id === rule.territory)) {
		throw new TypeError(`Unknown federal territory: ${rule.territory}`);
	}

	const authorized =
		rule.congressionalAuthorityVerified === true &&
		rule.rootDigest === federation.normativeRoot.digest &&
		rule.authenticated === true;

	return deepFreeze({
		status: authorized ? 'federal-rule-recognized' : 'requires-resolution',
		executable: authorized,
		territory: rule.territory,
		claimsPreserved: true,
		handoff: authorized ? 'territorial-administration' : 'article-iii:resolve',
		trace: [ARTICLE_IV.rules.property],
	});
}

export function authorizeProtection({ federation, request, plan }) {
	assertKnownState(federation, request.state, 'request.state');

	if (request.kind === 'republican-form') {
		return deepFreeze({
			status: 'requires-constitutional-determination',
			authorized: false,
			handoff: 'political-and-article-iii-boundary-review',
			trace: [ARTICLE_IV.rules.guarantee],
		});
	}

	const planConstrained =
		plan?.necessaryScopeVerified === true &&
		plan?.leastPrivilege === true &&
		typeof plan?.endsWhen === 'string' &&
		plan.endsWhen.trim() !== '' &&
		typeof plan?.reviewAt === 'string' &&
		plan.reviewAt.trim() !== '' &&
		plan?.permanentAuthorityTransfer === false;

	let constitutionalTrigger = false;

	if (request.kind === 'invasion') {
		constitutionalTrigger = request.threatVerified === true;
	} else if (request.kind === 'domestic-violence') {
		const legislatureApplied =
			request.applicant === 'state-legislature' && request.applicationAuthenticated === true;
		const executiveFallback =
			request.applicant === 'state-executive' &&
			request.legislatureCannotBeConvened === true &&
			request.applicationAuthenticated === true;

		constitutionalTrigger =
			request.threatVerified === true && (legislatureApplied || executiveFallback);
	} else {
		throw new TypeError('Unsupported protection request');
	}

	return deepFreeze({
		status:
			constitutionalTrigger && planConstrained
				? 'temporarily-authorized'
				: constitutionalTrigger
					? 'plan-rejected'
					: 'trigger-not-established',
		authorized: constitutionalTrigger && planConstrained,
		constitutionalTrigger,
		planConstrained,
		permanentAuthorityTransfer: false,
		handoff:
			constitutionalTrigger && planConstrained
				? 'federal-protective-function'
				: 'article-iii:resolve',
		trace: [ARTICLE_IV.rules.guarantee, ARTICLE_IV.engineering.protectiveIntervention],
	});
}

У коді присутні три види тверджень. ARTICLE_IV.rules фіксує буквальні положення статті IV і дію XIII поправки. ARTICLE_IV.doctrine містить розвинені судові конструкції: ефект остаточного рішення, equal footing і двоступеневу перевірку дискримінації громадян інших штатів. ARTICLE_IV.engineering додає правила «Конституції коду»: повний pipeline визнання, безпечне призупинення й обмежену захисну інтервенцію.

Такий поділ дозволяє читати trace кожного результату. Програма повідомляє підсумок і клас його підстави. Зміна інженерного safe state не переписує Конституцію. Зміна судової доктрини не маскується під редакцію вихідної статті. Поправка може змінити operative status історичної клаузи через нормативний root.

WARDEN: сорок два сценарії спільної мережі

Четверта батарея WARDEN перевіряє модуль на семи рівнях: сумісність збірок, реєстр юрисдикцій, міжштатні артефакти, становище громадян, передання відповідальності, зміна топології та захисна функція. Кожен сценарій оголошує джерело інваріанта. Спірний результат має перейти до article-iii:resolve; успішний тест WARDEN не отримує права замінити цей маршрут власною думкою.

flowchart TB
    A["Текст статті IV"] --> E["Інваріанти федерації"]
    B["Поправка XIII"] --> F["Статус історичної клаузи"]
    C["Судова доктрина й федеральні закони"] --> G["Ефект і сумісність"]
    D["Конституція коду"] --> H["Безпечний стан і межі втручання"]
    E --> I["WARDEN: 42 сценарії"]
    F --> I
    G --> I
    H --> I
    I --> J{"Усі переходи пояснювані?"}
    J -- "Так" --> K["Збірку допущено до статті III"]
    J -- "Ні" --> L["Перегляд коду, даних або класифікації"]

Повний тестовий файл можна зберегти як article-iv.test.mjs поруч із модулем і виконати командою node --test article-iv.test.mjs.

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

import {
	ARTICLE_IV,
	CURRENT_CLAUSE_STATUS,
	admitState,
	authorizeProtection,
	evaluateInterstateStanding,
	evaluateInterstateTransfer,
	federate,
	issueInterstateArtifact,
	recognizeInterstateArtifact,
	regulateFederalTerritory,
} from './article-iv.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: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-test',
		'sha256:root-after-article-v',
	]),
});

const states = [
	{
		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,
	territories: [{ id: 'Federal-Range', ruleRevision: 'territory-r1' }],
});

function judgment(overrides = {}) {
	return issueInterstateArtifact({
		federation,
		issuerState: 'Franklin',
		id: 'judgment:42',
		artifactClass: 'final-judgment',
		revision: 'r1',
		issuedAt: '2026-08-09',
		issuingAuthority: 'Franklin Superior Court',
		authorityScope: 'civil-judgment',
		final: true,
		stayed: false,
		payload: { debtor: 'A', creditor: 'B', amount: 500 },
		effectAtOrigin: 'enforce-money-judgment',
		...overrides,
	});
}

function recognition(artifact, overrides = {}) {
	return recognizeInterstateArtifact({
		federation,
		receivingState: 'Hamilton',
		artifact,
		proof: {
			authenticated: true,
			integrityDigest: artifact.digest,
			revisionVerified: true,
			originCompetenceVerified: true,
			...(overrides.proof ?? {}),
		},
		requestedEffect: overrides.requestedEffect ?? artifact.effectAtOrigin,
		meritsReviewRequested: overrides.meritsReviewRequested ?? false,
	});
}

function standing(overrides = {}) {
	return evaluateInterstateStanding({
		federation,
		citizenState: 'Franklin',
		hostState: 'Hamilton',
		personKind: 'natural-person',
		activity: 'pursue-common-calling',
		residentCondition: { fee: 100, examination: 'common' },
		visitorCondition: { fee: 100, examination: 'common' },
		classification: {},
		...overrides,
	});
}

function rendition(overrides = {}) {
	return evaluateInterstateTransfer({
		federation,
		request: {
			kind: 'criminal-rendition',
			demandingState: 'Franklin',
			asylumState: 'Hamilton',
			executiveDemandAuthenticated: true,
			chargeDocumentVerified: true,
			identityMatched: true,
			fugitiveStatusVerified: true,
			...overrides,
		},
	});
}

function candidate(overrides = {}) {
	return {
		id: 'Jay',
		constitutionDigest: 'sha256:jay',
		admissionDate: '2026-08-09',
		formation: 'external-territory',
		affectedStates: [],
		republicanFormVerified: true,
		...overrides,
	};
}

function admission(candidateValue, options = {}) {
	const probe = admitState({
		federation,
		candidate: candidateValue,
		congressionalAct: {},
		affectedStateConsents: options.consents ?? [],
	});
	const congressionalAct = options.congressionalAct ?? {
		authenticated: true,
		approved: true,
		candidateDigest: probe.candidateDigest,
		rootDigest: federation.normativeRoot.digest,
	};

	return admitState({
		federation,
		candidate: candidateValue,
		congressionalAct,
		affectedStateConsents: options.consents ?? [],
	});
}

const constrainedPlan = Object.freeze({
	necessaryScopeVerified: true,
	leastPrivilege: true,
	endsWhen: 'verified threat ends',
	reviewAt: '2026-08-10T00:00:00Z',
	permanentAuthorityTransfer: false,
});

wardenTest(
	'federate accepts the in-force root returned by the Article V model',
	[ARTICLE_IV.rules.admission],
	() => {
		assert.equal(federation.normativeRoot.digest, normativeRoot.digest);
		assert.deepEqual(federation.normativeRoot.lineage, normativeRoot.lineage);
		assert.equal(federation.states.length, 3);
	},
);

wardenTest('federate rejects a root that is not in force', [ARTICLE_IV.rules.admission], () => {
	assert.throws(
		() => federate({ normativeRoot: { ...normativeRoot, status: 'proposed' }, states }),
		/must be in force/,
	);
});

wardenTest(
	'federate rejects duplicate member-state identifiers',
	[ARTICLE_IV.rules.admission],
	() => {
		assert.throws(() => federate({ normativeRoot, states: [states[0], states[0]] }), /unique/);
	},
);

wardenTest(
	'federation snapshots are deeply immutable',
	[ARTICLE_IV.engineering.recognitionPipeline],
	() => {
		assert.equal(Object.isFrozen(federation), true);
		assert.equal(Object.isFrozen(federation.states), true);
		assert.throws(() => federation.states.push(states[0]));
	},
);

wardenTest(
	'a valid final judgment receives the same effect as at origin',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.doctrine.judgmentEffect],
	() => {
		const result = recognition(judgment());
		assert.equal(result.status, 'recognized');
		assert.equal(result.execution, 'same-effect-as-origin');
		assert.equal(result.effect, 'enforce-money-judgment');
	},
);

wardenTest(
	'the receiving state recognizes a judgment without retrying its merits',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.doctrine.judgmentEffect],
	() => {
		const result = recognition(judgment(), { meritsReviewRequested: true });
		assert.equal(result.status, 'recognized-with-merits-review-denied');
		assert.equal(result.meritsReview, 'denied-by-recognition-protocol');
	},
);

wardenTest(
	'an authenticated public record becomes available for its defined use',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.rules.proofAndEffect],
	() => {
		const artifact = judgment({
			artifactClass: 'public-record',
			id: 'record:birth:7',
			final: false,
			effectAtOrigin: 'evidence-of-recorded-birth',
		});
		const result = recognition(artifact);
		assert.equal(result.recognized, true);
		assert.equal(result.execution, 'record-available-for-defined-use');
	},
);

wardenTest(
	'recognition of a public act does not automatically execute it locally',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.rules.proofAndEffect],
	() => {
		const artifact = judgment({
			artifactClass: 'public-act',
			id: 'statute:licensing',
			final: false,
			effectAtOrigin: 'licensing-rule-at-origin',
		});
		const result = recognition(artifact);
		assert.equal(result.recognized, true);
		assert.equal(result.execution, 'requires-choice-of-law-and-local-operation');
	},
);

for (const [name, proof, expected] of [
	['unauthenticated artifact', { authenticated: false }, 'authentication'],
	['artifact with a different digest', { integrityDigest: 'sha256:forged' }, 'integrity'],
	['unverified revision', { revisionVerified: false }, 'revision'],
	['act outside verified competence', { originCompetenceVerified: false }, 'competence'],
]) {
	wardenTest(
		`${name} is suspended for Article III resolution`,
		[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.engineering.safeDispute],
		() => {
			const result = recognition(judgment(), { proof });
			assert.equal(result.status, 'requires-resolution');
			assert.equal(result.execution, 'suspended');
			assert.ok(result.failedChecks.includes(expected));
			assert.equal(result.handoff, 'article-iii:resolve');
		},
	);
}

wardenTest(
	'a stayed judgment is not executed in another state',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.engineering.safeDispute],
	() => {
		const result = recognition(judgment({ stayed: true }));
		assert.ok(result.failedChecks.includes('stayed-at-origin'));
		assert.equal(result.execution, 'suspended');
	},
);

wardenTest(
	'a nonfinal judgment does not enter the final-judgment route',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.doctrine.judgmentEffect],
	() => {
		const result = recognition(judgment({ final: false }));
		assert.ok(result.failedChecks.includes('finality'));
	},
);

wardenTest(
	'a receiving state cannot grant a judgment more or different effect than at origin',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.doctrine.judgmentEffect],
	() => {
		const result = recognition(judgment(), { requestedEffect: 'imprison-debtor' });
		assert.ok(result.failedChecks.includes('effect-exceeds-or-differs-from-origin'));
	},
);

wardenTest(
	'an artifact from a different constitutional revision is suspended',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.engineering.safeDispute],
	() => {
		const artifact = { ...judgment(), federationRootDigest: 'sha256:older-root' };
		const result = recognition(artifact, {
			proof: { integrityDigest: artifact.digest },
		});
		assert.deepEqual(result.failedChecks, ['constitutional-revision']);
	},
);

wardenTest(
	'an artifact from an expressly compatible earlier root remains recognizable',
	[ARTICLE_IV.rules.fullFaith, ARTICLE_IV.engineering.recognitionPipeline],
	() => {
		const oldRoot = {
			constitutionId: 'Constitution of 1787+amendment:xiii',
			digest: 'sha256:compatible-earlier-root',
			status: 'in-force',
			lineage: ['sha256:compatible-earlier-root'],
		};
		const oldFederation = federate({ normativeRoot: oldRoot, states });
		const artifact = issueInterstateArtifact({
			federation: oldFederation,
			issuerState: 'Franklin',
			id: 'judgment:before-upgrade',
			artifactClass: 'final-judgment',
			revision: 'r1',
			issuedAt: '2026-08-01',
			issuingAuthority: 'Franklin Superior Court',
			authorityScope: 'civil-judgment',
			final: true,
			stayed: false,
			payload: { result: 'final' },
			effectAtOrigin: 'enforce-final-judgment',
		});
		const upgradedFederation = federate({
			normativeRoot,
			states,
			compatibleArtifactRoots: [oldRoot.digest],
		});
		const result = recognizeInterstateArtifact({
			federation: upgradedFederation,
			receivingState: 'Hamilton',
			artifact,
			proof: {
				authenticated: true,
				integrityDigest: artifact.digest,
				revisionVerified: true,
				originCompetenceVerified: true,
			},
			requestedEffect: artifact.effectAtOrigin,
		});

		assert.equal(result.status, 'recognized');
	},
);

wardenTest(
	'equal resident and visitor conditions preserve interstate standing',
	[ARTICLE_IV.rules.privileges],
	() => {
		assert.equal(standing().status, 'equal-standing');
	},
);

wardenTest(
	'discrimination in a protected activity without a substantial reason fails',
	[ARTICLE_IV.rules.privileges, ARTICLE_IV.doctrine.privilegesReview],
	() => {
		const result = standing({ visitorCondition: { fee: 1000 } });
		assert.equal(result.status, 'unjustified-discrimination');
	},
);

wardenTest(
	'a substantial reason without a close relationship remains insufficient',
	[ARTICLE_IV.rules.privileges, ARTICLE_IV.doctrine.privilegesReview],
	() => {
		const result = standing({
			visitorCondition: { fee: 1000 },
			classification: {
				substantialReasonVerified: true,
				closeRelationshipToReasonVerified: false,
			},
		});
		assert.equal(result.status, 'unjustified-discrimination');
	},
);

wardenTest(
	'a verified substantial and closely related distinction is classified separately',
	[ARTICLE_IV.rules.privileges, ARTICLE_IV.doctrine.privilegesReview],
	() => {
		const result = standing({
			visitorCondition: { insurance: 'interstate-risk-cover' },
			classification: {
				substantialReasonVerified: true,
				closeRelationshipToReasonVerified: true,
			},
		});
		assert.equal(result.status, 'justified-distinction');
	},
);

wardenTest(
	'corporations remain outside this citizen-specific prototype',
	[ARTICLE_IV.rules.privileges],
	() => {
		const result = standing({ personKind: 'corporation' });
		assert.equal(result.status, 'outside-article-iv-privileges-model');
	},
);

wardenTest(
	'an unclassified activity is handed to legal classification',
	[ARTICLE_IV.rules.privileges],
	() => {
		const result = standing({ activity: 'operate-orbital-port' });
		assert.equal(result.status, 'requires-legal-classification');
	},
);

wardenTest(
	'a verified criminal rendition request enters executive transfer',
	[ARTICLE_IV.rules.extradition],
	() => {
		const result = rendition();
		assert.equal(result.status, 'eligible-for-rendition');
		assert.equal(result.handoff, 'executive-transfer');
	},
);

for (const [field, expected] of [
	['executiveDemandAuthenticated', 'executive-demand'],
	['chargeDocumentVerified', 'charge-document'],
	['identityMatched', 'identity'],
	['fugitiveStatusVerified', 'fugitive-status'],
]) {
	wardenTest(
		`criminal rendition stops when ${field} is false`,
		[ARTICLE_IV.rules.extradition],
		() => {
			const result = rendition({ [field]: false });
			assert.equal(result.status, 'requires-resolution');
			assert.ok(result.failedChecks.includes(expected));
		},
	);
}

wardenTest(
	'a fugitive-labor request is rejected under the current constitutional root',
	[ARTICLE_IV.rules.fugitiveLaborHistorical],
	() => {
		const result = evaluateInterstateTransfer({
			federation,
			request: { kind: 'fugitive-labor' },
		});
		assert.equal(result.status, 'rejected');
		assert.equal(result.executable, false);
		assert.equal(result.reason, 'superseded-by-amendment-xiii');
		assert.equal(CURRENT_CLAUSE_STATUS['IV.2.3'].operative, false);
	},
);

wardenTest(
	'Congress may admit an external candidate on equal footing',
	[ARTICLE_IV.rules.admission, ARTICLE_IV.doctrine.equalFooting],
	() => {
		const result = admission(candidate());
		assert.equal(result.status, 'admitted');
		assert.equal(result.standing, 'equal-footing');
		assert.equal(result.federation.states.length, 4);
	},
);

wardenTest('an existing member cannot be admitted twice', [ARTICLE_IV.rules.admission], () => {
	const result = admitState({
		federation,
		candidate: candidate({ id: 'Franklin' }),
		congressionalAct: {},
	});
	assert.equal(result.reason, 'state-already-member');
});

wardenTest(
	'a candidate without a proved congressional act is rejected',
	[ARTICLE_IV.rules.admission],
	() => {
		const result = admitState({
			federation,
			candidate: candidate(),
			congressionalAct: {},
		});
		assert.equal(result.reason, 'congressional-admission-not-proved');
	},
);

wardenTest(
	"a state formed inside an existing state requires that legislature's consent",
	[ARTICLE_IV.rules.admission],
	() => {
		const result = admission(
			candidate({ formation: 'within-state', affectedStates: ['Franklin'] }),
		);
		assert.equal(result.reason, 'affected-state-consent-missing');
		assert.deepEqual(result.missingConsentFrom, ['Franklin']);
	},
);

wardenTest(
	'authenticated affected-state consent completes a boundary admission',
	[ARTICLE_IV.rules.admission],
	() => {
		const candidateValue = candidate({
			formation: 'within-state',
			affectedStates: ['Franklin'],
		});
		const probe = admitState({ federation, candidate: candidateValue, congressionalAct: {} });
		const result = admission(candidateValue, {
			consents: [
				{
					state: 'Franklin',
					source: 'state-legislature',
					authenticated: true,
					candidateDigest: probe.candidateDigest,
					approved: true,
				},
			],
		});
		assert.equal(result.status, 'admitted');
	},
);

wardenTest(
	'a valid congressional rule governs a named federal territory and preserves claims',
	[ARTICLE_IV.rules.property],
	() => {
		const result = regulateFederalTerritory({
			federation,
			rule: {
				territory: 'Federal-Range',
				congressionalAuthorityVerified: true,
				authenticated: true,
				rootDigest: federation.normativeRoot.digest,
			},
		});
		assert.equal(result.status, 'federal-rule-recognized');
		assert.equal(result.claimsPreserved, true);
	},
);

wardenTest(
	'a territorial rule from another root awaits resolution',
	[ARTICLE_IV.rules.property],
	() => {
		const result = regulateFederalTerritory({
			federation,
			rule: {
				territory: 'Federal-Range',
				congressionalAuthorityVerified: true,
				authenticated: true,
				rootDigest: 'sha256:wrong-root',
			},
		});
		assert.equal(result.status, 'requires-resolution');
	},
);

wardenTest(
	'verified invasion triggers constrained protection without a state application',
	[ARTICLE_IV.rules.guarantee, ARTICLE_IV.engineering.protectiveIntervention],
	() => {
		const result = authorizeProtection({
			federation,
			request: { state: 'Franklin', kind: 'invasion', threatVerified: true },
			plan: constrainedPlan,
		});
		assert.equal(result.status, 'temporarily-authorized');
	},
);

wardenTest(
	'a legislature may request protection against verified internal violence',
	[ARTICLE_IV.rules.guarantee],
	() => {
		const result = authorizeProtection({
			federation,
			request: {
				state: 'Franklin',
				kind: 'domestic-violence',
				threatVerified: true,
				applicant: 'state-legislature',
				applicationAuthenticated: true,
			},
			plan: constrainedPlan,
		});
		assert.equal(result.authorized, true);
	},
);

wardenTest(
	'a state executive may use the fallback when the legislature cannot convene',
	[ARTICLE_IV.rules.guarantee],
	() => {
		const result = authorizeProtection({
			federation,
			request: {
				state: 'Franklin',
				kind: 'domestic-violence',
				threatVerified: true,
				applicant: 'state-executive',
				legislatureCannotBeConvened: true,
				applicationAuthenticated: true,
			},
			plan: constrainedPlan,
		});
		assert.equal(result.authorized, true);
	},
);

wardenTest(
	'an executive request does not bypass a legislature that can convene',
	[ARTICLE_IV.rules.guarantee],
	() => {
		const result = authorizeProtection({
			federation,
			request: {
				state: 'Franklin',
				kind: 'domestic-violence',
				threatVerified: true,
				applicant: 'state-executive',
				legislatureCannotBeConvened: false,
				applicationAuthenticated: true,
			},
			plan: constrainedPlan,
		});
		assert.equal(result.status, 'trigger-not-established');
	},
);

wardenTest(
	'an unlimited protection plan is rejected even after a valid trigger',
	[ARTICLE_IV.rules.guarantee, ARTICLE_IV.engineering.protectiveIntervention],
	() => {
		const result = authorizeProtection({
			federation,
			request: { state: 'Franklin', kind: 'invasion', threatVerified: true },
			plan: { ...constrainedPlan, leastPrivilege: false },
		});
		assert.equal(result.status, 'plan-rejected');
		assert.equal(result.permanentAuthorityTransfer, false);
	},
);

wardenTest(
	'the republican-form guarantee remains a constitutional determination boundary',
	[ARTICLE_IV.rules.guarantee],
	() => {
		const result = authorizeProtection({
			federation,
			request: { state: 'Franklin', kind: 'republican-form' },
			plan: constrainedPlan,
		});
		assert.equal(result.status, 'requires-constitutional-determination');
		assert.equal(result.authorized, false);
	},
);

Усі сорок два сценарії проходять. Змістовно важливими стали чотири негативні результати. Підроблений digest зупиняє виконання. Судове рішення не отримує більшого ефекту після перетину кордону. Новий штат усередині наявного не виникає без згоди заторкнутої легіслатури. Запит про повернення втікача з рабства відхиляється за чинним root, хоча історичне джерело залишається у trace.

Окремий тест підтверджує сумісність попереднього артефакту після конституційного оновлення. Старе рішення визнається лише тоді, коли перехід статті V включив його root до засвідченого переліку сумісності. Цей механізм зберігає правову пам’ять і водночас забороняє робити зі слова legacy релігійну підставу вічного життя будь-якої поведінки.

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

Четверта публікація залишає вісім практичних висновків.

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

Спільний root зберігає локальні джерела. Кожен штат зберігає власну конституцію та компетентні органи. Спільний порядок визначає контракти перетину кордонів і межі локального рішення.

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

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

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

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

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

Редакція root керує історичним спадком. Новий порядок може зберігати старий текст для аудиту, визнавати сумісні попередні результати й забороняти скасовану операцію. Це розрізнення особливо важливе для систем, де попередня архітектура одночасно накопичувала технічний борг і продукувала людські жертви.

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

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

Стаття IV переноситься в код нерівномірно. Ідентифікатори, digest, унікальність учасників, збіг редакцій і наявність згод можна перевірити безпосередньо. Компетенція, остаточність, захищена діяльність, істотна причина, республіканська форма й факт вторгнення надходять через інституційні рішення.

Full Faith and Credit особливо опирається універсальній функції. Остаточні судові рішення отримують сильний міжштатний ефект. Публічні закони зберігають простір вибору застосовного права. Записи мають власні режими доказування. Прототип фіксує ці класи й зупиняється до повноцінної доктрини колізійного права.

Privileges and Immunities Clause також не дорівнює загальному оператору resident === visitor. Захищеність діяльності й допустимість розрізнення розвинулися в судових справах. Перелік прототипу демонструє маршрут і не претендує на вичерпний каталог прав.

Guarantee Clause містить політичні й судові межі, які програма не може вирішити самостійно. Поле republicanFormVerified представляє встановлений факт і зберігає його джерело; воно не доводить якості виборів, представництва та інститутів. Інженерні обмеження protective intervention походять із «Конституції коду» й позначені окремо.

Модель приєднання не реалізує весь історичний процес утворення територій і штатів. Вона перевіряє конституційні ворота, рівне становище та зміну topology digest. Договори, enabling acts, перехідні органи, борги, землі, відносини з корінними народами й фактичне створення інститутів потребують окремої міграції. Історія розширення США також включає завоювання, витіснення й примусову зміну чужого політичного порядку; святкова карта вузлів здатна приховати це швидше, ніж імперія встигне надрукувати слово admission.

Нарешті, код поки вміє лише передати спір статті III. Він не знає складу суду, предметної юрисдикції, доказового стандарту, сили прецеденту й способу відновлення. Ця відсутність визначає наступний інтерфейс серії. Універсальний throw new ConstitutionalError() лише прикрасив би прогалину.

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

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

Висновок

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

У коді цей порядок утворюють federate(), три класи міжюрисдикційних артефактів, pipeline доказування, перевірка рівного становища, контрольована видача, транзакція приєднання, реєстр територій і тимчасова захисна функція. Чинний root зберігає сумісні попередні результати й блокує скасовану рабовласницьку операцію. Спірні факти переходять у безпечний стан і передаються наступній підсистемі.

Програмна інтерпретація витримує четверту перевірку. Вона вже описує порядок, здатний засновуватися, доводити походження, змінювати власну основу й підтримувати горизонтальну сумісність автономних частин. Після цієї публікації залишаються три збірки: стаття III додасть resolve(), стаття II — execute(), стаття I — legislate(). Сьома публікація водночас завершить цикл, з’єднає всі функції й дасть підсумкову оцінку адаптивності конституційної моделі до software governance.

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

Сайт формує цей розділ із незалежного набору питань constitution-runtime.article-iv.federate, що зберігається в супровідному каталозі constitution-runtime-04-article-iv-questions.yaml. Кожен запит самостійно називає предмет статті IV, конституційне джерело, програмний об’єкт і межу спору, тому може діяти поза лінійною статтею без втрати контексту.

Рекомендований маршрут: спільний root → автономна юрисдикція → визнання → становище громадянина → передання відповідальності → чинна редакція → зміна топології → захист → WARDEN → межа. Двомовний каталог містить контракт відповіді ШІ, шістдесят самостійних запитів, умови відкриття гілок, посилання на код і графіку та навігацію повернення.

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

Автори: Sam Starling, Oksana Dubinetska
Контекст проєкту: Zhovten Games / IRONCREED
Повне джерело дослідження: «Конституція коду» — DOI 10.5281/zenodo.21894242
Репозиторій дослідження: FOP-Oksana-Dubinetska/code-constitution
Історичні, юридичні й технічні матеріали: текст Конституції США; огляд статті IV; Full Faith and Credit Clause; сучасна доктрина про судові рішення; сучасна доктрина про закони штатів; 28 U.S.C. § 1738; Privileges and Immunities Clause; Extradition Clause; Fugitive Slave Clause; XIII поправка; Admissions Clause; Equal Footing Doctrine; Property Clause; Guarantee Clause; історичне значення domestic Violence
Пов’язані публікації: «Підключити Америку: як стаття VII запускає республіку»; «Чому довіряє Америка: як стаття VI збирає верховний порядок»; «Оновити Америку: як стаття V змінює конституційне ядро»
Наступна публікація: стаття III — у розробці
Редакція публікації: 0.2 · 13 серпня 2026 року