Link America: How Article IV Turns the States into a Federal Network

Starting question

How can several autonomous jurisdictions preserve their own state while forming one system in which documents, decisions, citizens, obligations, and new members cross internal borders?

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

The map is already lit

In our Death Stranding playthrough, connecting another node to the chiral network changed the entire area, beginning with the color of the map. Traces of other people’s work appeared there: bridges, roads, ladders, warnings, and routes made by other players. An object built in somebody else’s playthrough became a fact in our surroundings. We could use it, reinforce it, ignore it, or discover that another person’s ladder led into an abyss with the confident tone normally reserved for infrastructure and public registries.

This kind of connection offers a useful entrance into Article IV. Earlier publications in the cycle have already created a common order. Article VII started the Constitution among the ratifying states. Article VI established the canonical corpus and root of trust. Article V allowed that corpus to update itself. After the third build, the map exists, the revision is known, and the provenance of authority has been proved. The next problem arises between the nodes.

A state may enact a law, register a marriage, issue a certificate, enter a judgment, charge a person with a crime, establish a professional requirement, or request federal protection. Another state retains its own institutions, law, and procedures. A federation functions when the border between them remains both real and passable. Complete merger would destroy autonomy. Complete isolation would turn the Union into a collection of adjacent production environments, each treating somebody else’s JSON as a political declaration.

Article IV designs the Constitution’s horizontal layer. It establishes recognition of other states’ acts, records, and judicial proceedings; protects a defined standing of citizens crossing state borders; returns an accused person to the state with jurisdiction over the alleged crime; regulates the admission of new states and certain boundary changes; establishes federal governance of territories and property; and guarantees states a republican form of government and protection in specified circumstances.

In software form, this layer becomes federate(). The function creates a registry of autonomous jurisdictions under one root in force, while the related operations determine which events may cross a border, what effect they receive, and where processing must stop for dispute resolution.

The fourth build

For the first time, the reverse route through the cycle leaves the history of one common artifact and enters a space of several local states.

The fourth build accepts the normativeRoot returned by the Article V model and adds eight elements:

1. a registry of states with their own constitutional digests;
2. a registry of territories as a distinct domain of federal governance;
3. a protocol for issuing an interstate artifact;
4. a recognition protocol that verifies provenance, integrity, revision, competence, and finality;
5. a check of equal standing for a citizen of another state;
6. controlled transfer of criminal responsibility between states;
7. a transaction for admitting a new state and changing the topology;
8. a constrained model of the federal protective function.

The result becomes the cycle’s first genuinely distributed object. It contains several owners of state, several sources of derivative decisions, messages between nodes, compatibility rules, changes in network membership, and a separate route for disputes. The principal root remains common, while local constitutions and institutions retain their status as independent sources rather than caches of the federal administration.

The article of horizontal relationships

Article IV’s four sections perform distinct functions that should remain separate.

This map immediately reveals the limit of a simple microservice analogy. An ordinary service has no constitution, citizens, or territory of its own, and its API contract is not guaranteed by a political system capable of coercion. The technical model remains useful when it describes provenance, boundaries, contracts, and transitions. It becomes decorative when a state is renamed service-west-1 and the author declares federalism successfully deployed.

Full Faith and Credit: another state’s decision becomes a local fact

Section 1 of Article IV requires each state to give full faith and credit to the public acts, records, and judicial proceedings of every other state. It also empowers Congress, by general laws, to prescribe how those artifacts are proved and what effect they receive. A current implementation of that power includes 28 U.S.C. § 1738, which regulates authentication and requires properly authenticated materials to receive the same full faith and credit they possess in the courts of their state of origin.

The word “recognition” requires precision here. It establishes the normative significance of another jurisdiction’s result, while execution forms a separate subsequent stage.

The rule is especially strong for final judgments. The receiving state ordinarily gives a valid final judgment the same effect it possesses in the state of origin. The second state receives no ordinary license to retry the merits merely because the losing party crossed a border. Jurisdiction, due process, finality, authenticity, and current status remain subject to verification; a convenient retrial by the receiving node would destroy the protocol itself.

Public laws operate more intricately. Article IV does not turn every state’s law into a global stylesheet that automatically recolors every other jurisdiction. Choice of applicable law, the relationship’s connection with a state, and the limits of a state’s own public policy have developed through judicial doctrine. Constitution Annotated on judgments describes the strong regime for judgments, while its materials on state law preserve a more complex analysis for statutes.

The executable model therefore separates recognized from execution. A public act enters the applicable-law analysis. A record receives a specified evidentiary use. A final judgment receives the same effect proved in the originating jurisdiction. The requested effect cannot exceed the original one: a debt cannot become imprisonment by merely changing the endpoint.

flowchart TB
    A["Act, record, or judgment of the state of origin"] --> B["Provenance, integrity, and revision"]
    B --> C{"Competence and operative status verified?"}
    C -- "No" --> D["Suspend and hand off to Article III"]
    C -- "Yes" --> E{"Artifact class"}
    E --> F["Judgment: same effect as at origin"]
    E --> G["Public act: applicable-law analysis"]
    E --> H["Public record: defined evidentiary value"]

Recognition begins before execution

Code Constitution develops horizontal compatibility through six checks: provenance, integrity, revision, competence, finality, and contemplated effect. This sequence extends the literal text of Article IV with an engineering contract that automates recognition without automating credulity.

issueInterstateArtifact() binds every artifact to the federation root, its state of origin, class, revision, issuing institution, subject-matter competence, status, and effect in the originating jurisdiction. A digest confirms the exact serialized content. recognizeInterstateArtifact() recalculates the digest and considers evidence of authenticity, revision, and competence. The single line authenticated: true remains the result of an external check; the code does not impersonate a notary through a Boolean value.

Compatibility with previous root revisions is explicit. An amendment should not automatically invalidate every older certificate and judgment. compatibleArtifactRoots contains earlier revisions whose artifacts survive the transition under the verified Article V plan. An unknown revision moves the operation to requires-resolution. This decision prevents two symmetrical errors: limitless trust in every legacy artifact and ceremonial destruction of all memory after each update.

When a check fails, the module suspends execution, preserves reversibility, and hands the issue to the future Article III resolve() function. WARDEN receives no judicial mandate. It can prove that the program stopped at a declared boundary; authority to decide the dispute appears only in the next build.

A citizen crosses a border

The first sentence of Section IV.2 grants the citizens of each state the privileges and immunities of citizens in the several states. This formula does not unify all local law or make residence legally invisible. It protects fundamental forms of interstate activity from unjustified discrimination based on citizenship in another state.

Judicial doctrine uses a two-stage inquiry. First, the decision-maker determines whether the affected activity belongs to the protected category. Then the state imposing the distinction must demonstrate a substantial reason and a close relationship between the restriction and that reason. The Privileges and Immunities Clause overview connects the clause with restrictions on discrimination against nonresidents in fundamental activities; related materials discuss professions, access to courts, property, and taxation.

The prototype deliberately uses a narrow list of already classified activities: pursuit of a common calling, access to courts, and ownership or transfer of property. An unknown activity receives requires-legal-classification. A corporation receives outside-article-iv-privileges-model, because this particular clause concerns citizens and corporations are not citizens for its purposes. A complete system of equal protection, freedom of movement, and federal citizenship also requires the Fourteenth Amendment and other doctrine; Article IV should not absorb later layers into one convenient person object.

flowchart TB
    A["Citizen of State A acts in State B"] --> B{"Activity protected by Article IV?"}
    B -- "Classification required" --> C["Hand off for competent review"]
    B -- "Yes" --> D{"Conditions equal to those of residents?"}
    D -- "Yes" --> E["Equal standing"]
    D -- "No" --> F{"Substantial reason and close relationship proved?"}
    F -- "Yes" --> G["Justified distinction"]
    F -- "No" --> H["Remove condition or challenge"]

Transferring responsibility without erasing the border

The second sentence of Section IV.2 governs interstate rendition of accused persons. When a person is charged in one state, leaves it, and is found in another, the executive authority of the demanding state requests delivery to the jurisdiction of the alleged crime. Modern practice permits federal judicial enforcement of that duty; Constitution Annotated provides an overview of the mechanism.

evaluateInterstateTransfer() verifies the authenticity of the executive demand, the presence of a verified charging instrument, identity matching, and an established fugitive-from-justice status. A successful result hands the operation to the executive circuit that Article II will describe in full. A failed check hands the issue to Article III. The module determines route eligibility rather than guilt or the merits of a criminal proceeding.

This order demonstrates the distinction between recognition and transfer of responsibility. The asylum state does not declare the accusation true. It recognizes a defined class of request, verifies the required conditions, and returns the person to the jurisdiction where a competent court will consider the charge. The federal border remains in place while refusing to become a call-stack reset button.

A historical packet the current revision must reject

The third sentence of the original Section IV.2 required the return of people “held to Service or Labour” who escaped into another state. The legal euphemism described a slaveholding system. Federal compatibility included a duty of a free state to assist in restoring an enslaver’s power over a human being.

Here the software metaphor reaches a morally important boundary. The original architecture truly contained an interstate protocol, and one of its transferable objects was a person transformed by law into somebody else’s resource. The republic mastered seamless integration early: the payload screamed, while the specification classified it as transport noise.

The Thirteenth Amendment prohibited slavery and involuntary servitude in the United States, except as punishment for a crime after due conviction. The National Archives states that it superseded the corresponding part of Article IV; its history and text of the Thirteenth Amendment records ratification on December 6, 1865. Constitution Annotated describes the Fugitive Slave Clause as effectively nullified by the abolition of slavery.

The fourth module therefore preserves the line in the historical corpus while refusing to execute it. CURRENT_CLAUSE_STATUS["IV.2.3"] retains the provenance, sets operative: false, and binds the status to the Thirteenth Amendment. Every fugitive-labor request receives rejected. For the first time, this check puts the previous publication’s result to practical use: the updated root changes the behavior of an older section.

The legacy remains available for audit and unavailable for execution. This state is more accurate than deletion, which erases provenance, and safer than “backward compatibility,” which can sometimes mean readiness to resurrect barbarism for the sake of a green pipeline.

New nodes change the topology

Section IV.3 gives Congress power to admit new states. It also prohibits forming a new state within the jurisdiction of another state or creating one by combining states or their parts without the consent of the legislatures concerned and Congress. A change in federal membership thereby becomes a transaction with several independent confirmations.

admitState() binds the candidate to the current root, its own constitution, an admission date, a method of formation, and a list of affected states. Congress confirms one candidate digest. Every affected legislature confirms the same revision. A duplicate existing state, mismatched digest, absent act of Congress, or missing local consent leaves the previous topology unchanged.

After successful admission, the new state receives equal-footing standing. The equality of new states developed as constitutional doctrine: Constitution Annotated explains that a new state enters with the same sovereign powers and jurisdiction as the existing states. Congress may establish preconditions for admission, but it may not keep a new participant permanently in member-lite mode when that restriction violates the equality of states.

flowchart TB
    A["Candidate for new statehood"] --> B["Exact admission revision and digest"]
    B --> C{"Act of Congress verified?"}
    C -- "No" --> D["Current topology remains"]
    C -- "Yes" --> E{"Existing state boundaries change?"}
    E -- "No" --> H["Admission to the Union"]
    E -- "Yes" --> F{"Consent of every affected legislature?"}
    F -- "No" --> D
    F -- "Yes" --> H
    H --> I["Equal standing of the new state"]

Article IV describes entry and particular boundary changes. It supplies no protocol for unilateral withdrawal of a state from the Union. Code Constitution includes a general exit question for software federations, but the American adaptation receives no leaveUnion() from the text of Article IV. The program preserves the absence of the operation instead of generating a convenient path by analogy with deleting a worker node.

A territory is a distinct class of domain

The second clause of Section IV.3 gives Congress power to dispose of and make necessary rules concerning the territory or other property of the United States. Its concluding saving clause preserves claims of the United States and individual states against adverse construction of the Constitution itself. The Property Clause overview and materials on congressional authority describe the breadth of this federal subject.

The software model stores territories separately from states. regulateFederalTerritory() requires a verified act of Congress, a matching root, and a known territory. Its result receives claimsPreserved: true, because a rule governing the common domain must not silently resolve a separate property claim. Such a dispute again belongs to Article III.

The distinction between a state and a territory is material. Both objects may contain population, administration, data, and infrastructure. Their technical richness does not create the same jurisdictional category. In Code Constitution, a separate repository, language, team, or deployment likewise creates no autonomy by itself; jurisdiction arises through a recognized allocation of powers, state, obligations, and methods of conflict resolution.

The system guarantee and temporary protection

Section IV.4 imposes three related obligations on the United States: to guarantee every state a republican form of government, protect each state against invasion, and protect it against domestic violence on application of its legislature—or its executive when the legislature cannot be convened.

The phrase domestic Violence in the eighteenth-century text means internal uprising or unlawful force within the political community. The modern phrase “domestic violence” ordinarily refers to violence within a family and produces a false reading here. The historical overview of the Guarantee Clause explicitly notes the archaic meaning.

The model distinguishes three routes. A verified invasion creates a federal protective duty without a prior state application. Domestic violence requires an authenticated application from the legislature; the state executive receives a reserve route only when the legislature cannot be convened. A dispute over republican form receives requires-constitutional-determination, because the content of the guarantee and the limits of judicial review have developed through political and judicial practice. The Boolean field republican: true can decorate an object but has not yet learned how to establish a republic.

The protection-plan constraints come from Code Constitution, rather than the literal list in Article IV. The prototype requires necessary scope, least privilege, a review date, a termination condition, and a prohibition on permanent transfer of authority. Federal protection receives a temporary capability and never becomes a concealed means of appropriating local jurisdiction.

flowchart TB
    A["Threat to a state"] --> B{"Threat type"}
    B --> C["Invasion: verified fact"]
    B --> D["Domestic violence: application by legislature"]
    D --> E["Fallback: executive when legislature cannot convene"]
    C --> F["Constrained protection plan"]
    E --> F
    F --> G{"Purpose, scope, duration, and exit defined?"}
    G -- "Yes" --> H["Temporary federal function"]
    G -- "No" --> I["Reject or review"]

An executable federation

The module is an ESM file for Node.js and uses only the standard library. It may be saved as article-iv.mjs. It is compatible with the constitutionalRoot object returned by attestAndIntegrate() in the third publication: constitutionId, digest, and the in-force state remain required, while lineage is carried into the federation snapshot.

The central federate() function does not perform every operation itself. It establishes a verifiable environment and returns registries, a topology digest, and four protocols. The other exported functions modify or verify a particular class of relationship. This separation reflects Article IV itself: recognition of a judgment, a citizen’s standing, rendition of an accused person, admission of a state, and protective intervention have different sources, data, and consequences.

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

The code contains three kinds of assertions. ARTICLE_IV.rules records the literal provisions of Article IV and the effect of the Thirteenth Amendment. ARTICLE_IV.doctrine contains developed judicial constructions: the effect of a final judgment, equal footing, and the two-stage inquiry into discrimination against citizens of other states. ARTICLE_IV.engineering adds the rules of Code Constitution: the complete recognition pipeline, safe suspension, and constrained protective intervention.

This separation makes the trace of every result readable. The program reports both the outcome and the class of its foundation. Changing an engineering safe state does not rewrite the Constitution. A change in judicial doctrine does not masquerade as a revision of the original article. An amendment can change the operative status of a historical clause through the normative root.

WARDEN: forty-two scenarios for a common network

The fourth WARDEN suite tests the module at seven levels: build compatibility, jurisdiction registry, interstate artifacts, citizens’ standing, transfer of responsibility, topology change, and the protective function. Every scenario declares the source of its invariant. A contested result must proceed to article-iii:resolve; a successful WARDEN test acquires no authority to replace that route with its own opinion.

flowchart TB
    A["Text of Article IV"] --> E["Federal invariants"]
    B["Thirteenth Amendment"] --> F["Status of the historical clause"]
    C["Judicial doctrine and federal statutes"] --> G["Effect and compatibility"]
    D["Code Constitution"] --> H["Safe state and limits of intervention"]
    E --> I["WARDEN: 42 scenarios"]
    F --> I
    G --> I
    H --> I
    I --> J{"Are all transitions explainable?"}
    J -- "Yes" --> K["Build admitted to Article III"]
    J -- "No" --> L["Review code, data, or classification"]

The complete test file may be saved as article-iv.test.mjs beside the module and executed with 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);
	},
);

All forty-two scenarios pass. Four negative results carry particular substantive importance. A forged digest suspends execution. A judgment receives no greater effect after crossing a border. A new state cannot appear inside an existing one without consent from the affected legislature. A request to return a fugitive slave is rejected under the current root, while the historical source remains present in the trace.

A separate test confirms compatibility of an older artifact after a constitutional update. The old judgment is recognized only when the Article V transition placed its root in an authenticated compatibility list. This mechanism preserves legal memory while preventing the word legacy from becoming a religious basis for the eternal life of every behavior.

What Article IV gives software architecture

The fourth publication leaves eight practical conclusions.

Authority and state define autonomy. A separate deployment, repository, or team creates a technical boundary. A jurisdiction arises through a recognized allocation of decisions, obligations, state, and methods of conflict resolution.

A common root preserves local sources. Every state retains its own constitution and competent institutions. The common order defines contracts for crossing boundaries and the limits of local decisions.

Recognition precedes execution. An artifact from another jurisdiction first receives proved provenance, class, and normative effect. A separate step performs the concrete technical operation in the receiving domain.

Compatibility depends on the class of result. A judgment, public act, and public record require different regimes. A universal trustRemoteObject() remains convenient precisely until the first object turns out to be a statute, sentence, or birth certificate.

A subject preserves standing while moving. An internal border does not demote a citizen of another state to a lower class. A justified distinction requires a stated risk, criterion, and relationship to the applied measure.

Topology change is a transaction. Admission, partition, and combination affect several owners of state. The exact artifact, independent consents, transition moment, and equal standing of the new participant must be established before the network changes.

Protective access creates no permanent ownership. A temporary federal capability receives a foundation, minimum scope, audit, and termination condition. Duration of actual control alone does not redistribute constitutional authority.

The root revision governs historical legacy. A new order can preserve old text for audit, recognize compatible older results, and prohibit a superseded operation. This distinction is especially important for systems in which former architecture accumulated technical debt while also producing human casualties.

These properties apply to platforms with autonomous teams, federated registries, supply chains, distributed organizations, identity systems, and long-lived products with several owners of data. Article IV offers a discipline of boundaries: local freedom of decision operates together with a common protocol of proof, compatibility, admission, and protection.

Where the fourth experiment ends

Article IV transfers into code unevenly. Identifiers, digests, participant uniqueness, matching revisions, and the existence of consents can be verified directly. Competence, finality, protected activity, substantial reason, republican form, and the fact of invasion arrive through institutional determinations.

Full Faith and Credit particularly resists a universal function. Final judgments receive a strong interstate effect. Public laws retain space for choice of law. Records possess their own modes of proof. The prototype records these classes and stops before attempting a complete conflicts-of-law doctrine.

The Privileges and Immunities Clause likewise cannot be reduced to a general resident === visitor operator. Protected activity and permissible distinctions developed through judicial decisions. The prototype’s list demonstrates the route rather than claiming to be an exhaustive catalog of rights.

The Guarantee Clause contains political and judicial boundaries that the program cannot resolve independently. republicanFormVerified represents an established fact and preserves its source; it does not prove the quality of elections, representation, or institutions. The engineering constraints on protective intervention come from Code Constitution and remain separately labeled.

The admission model does not implement the entire historical process of creating territories and states. It verifies the constitutional gates, equal standing, and a change to the topology digest. Treaties, enabling acts, transitional institutions, debts, land, relations with Indigenous peoples, and material creation of institutions require a separate migration. The history of United States expansion also includes conquest, displacement, and forced alteration of other political orders; a celebratory map of nodes can conceal that history faster than an empire can print the word admission.

Finally, the code currently knows only how to hand a dispute to Article III. It knows neither court composition, subject-matter jurisdiction, evidentiary standards, precedential force, nor remedy. This absence defines the next interface in the series. A universal throw new ConstitutionalError() would merely decorate the gap.

WARDEN confirms that the implementation conforms to the selected invariants. It does not establish completeness of American constitutional law or grant the program authority to decide human disputes. The fourth experiment survives testing as an architecture of federal boundaries, while its execution continues to depend on courts, public institutions, documents, and material capacity to implement a decision.

The eagle now travels between autonomous nodes, accepts only authenticated packets, and knows that a green network status still says nothing about the moral permissibility of the protocol. For a symbolic bird, that is considerable career development.

Conclusion

Article VII gave the system its moment of establishment. Article VI established the canonical corpus and root of trust. Article V taught that root to update itself. Article IV turns the common order into a federation: several states retain their own state, recognize specified acts of one another, preserve citizens’ standing across borders, transfer responsibility to the proper jurisdiction, admit new participants, and receive common protection.

In code, this order consists of federate(), three classes of interstate artifacts, a proof pipeline, an equal-standing inquiry, controlled rendition, an admission transaction, a territory registry, and a temporary protective function. The current root preserves compatible older results and blocks a superseded slaveholding operation. Disputed facts enter a safe state and proceed to the next subsystem.

The software interpretation survives its fourth test. It now describes an order capable of establishing itself, proving provenance, changing its own foundation, and maintaining horizontal compatibility between autonomous parts. Three builds remain after this publication: Article III adds resolve(), Article II adds execute(), and Article I adds legislate(). The seventh publication will also complete the cycle, connect every function, and offer a final assessment of the constitutional model’s adaptability to software governance.

Continue the research with AI

The site renders this section from the independent question set constitution-runtime.article-iv.federate, stored in the companion catalog constitution-runtime-04-article-iv-questions.yaml. Every prompt independently identifies its Article IV subject, constitutional source, software object, and dispute boundary, allowing it to operate outside the linear article without losing context.

The recommended route is common root → autonomous jurisdiction → recognition → citizens’ standing → transfer of responsibility → operative revision → topology change → protection → WARDEN → limit. The bilingual catalog contains the AI answer contract, sixty standalone prompts, branch triggers, code and visual references, and return navigation.

Publication information

Authors: Sam Starling, Oksana Dubinetska
Project context: Zhovten Games / IRONCREED
Complete research source: Code Constitution — DOI 10.5281/zenodo.21894242
Research repository: FOP-Oksana-Dubinetska/code-constitution
Historical, legal, and technical materials: text of the United States Constitution; overview of Article IV; Full Faith and Credit Clause; modern doctrine on judgments; modern doctrine on state laws; 28 U.S.C. § 1738; Privileges and Immunities Clause; Extradition Clause; Fugitive Slave Clause; Thirteenth Amendment; Admissions Clause; Equal Footing Doctrine; Property Clause; Guarantee Clause; historical meaning of domestic Violence
Related publications: “Connect America: How Article VII Bootstraps a Republic”; “What America Trusts: How Article VI Assembles the Supreme Order”; “Update America: How Article V Changes the Constitutional Kernel”
Next publication: Article III — in development
Publication revision: 0.2 · 13 August 2026