@wasm-oj/organizer 0.2.0 → 0.2.1

package/dist/index.js

@@ -1,9 +1,1919 @@
 import { constants } from "node:fs";
-import { lstat, mkdir, open, readdir, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { lstat, mkdir, open, realpath, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, BROWSER_PROBLEM_SCHEMA as BROWSER_PROBLEM_SCHEMA$1, assertJudgeDataMatchesPracticePublic, canonicalJsonBytes, deriveContestPublic, deriveJudgeData, derivePracticePublic, encodeJudgePackage, parseProblemCollectionIndex, parseStandaloneProblemBundle, parseStandaloneProblemBundle as parseStandaloneProblemBundle$1, problemCollectionRevision, validateJudgePackage, verifyProblemBundleBytes, verifyProblemCollectionRevision } from "@wasm-oj/core";
+import { isBuiltinLanguage } from "@wasm-oj/contracts";
 import os from "node:os";
-import { BROWSER_COLLECTION_SCHEMA, BROWSER_COLLECTION_SCHEMA as BROWSER_COLLECTION_SCHEMA$1, BROWSER_PROBLEM_SCHEMA, BROWSER_PROBLEM_SCHEMA as BROWSER_PROBLEM_SCHEMA$1, MANAGED_COLLECTION_SCHEMA, MANAGED_COLLECTION_SCHEMA as MANAGED_COLLECTION_SCHEMA$1, assertJudgeDataMatchesPracticePublic, canonicalJsonBytes, contestPublicProjectionBytes, deriveJudgeData, derivePracticePublic, encodeJudgePackage, parseManagedCollectionContract, parseManagedCollectionSource, parseManagedCollectionSource as parseManagedCollectionSource$1, parseManagedCollectionV2, parseManagedCollectionV2 as parseManagedCollectionV2$1, parseManagedCollectionValueV2, parseProblemCollectionIndex, parseProblemCollectionIndex as parseProblemCollectionIndex$1, parseStandaloneProblemBundle, parseStandaloneProblemBundle as parseStandaloneProblemBundle$1, problemCollectionRevision, problemCollectionRevision as problemCollectionRevision$1, validateJudgePackage, verifyProblemBundleBytes, verifyProblemBundleBytes as verifyProblemBundleBytes$1, verifyProblemCollectionRevision, verifyProblemCollectionRevision as verifyProblemCollectionRevision$1 } from "@wasm-oj/core";
+//#region src/core/canonical-json.ts
+var encoder = new TextEncoder();
+function canonicalValue(value, path, ancestors) {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+	if (typeof value === "number") {
+		if (!Number.isSafeInteger(value)) throw new TypeError(`${path} must be a safe integer.`);
+		return value;
+	}
+	if (typeof value !== "object" || value === void 0) throw new TypeError(`${path} is not canonical JSON data.`);
+	if (ancestors.has(value)) throw new TypeError(`${path} contains a cycle.`);
+	const nextAncestors = new Set(ancestors).add(value);
+	if (Array.isArray(value)) return value.map((item, index) => canonicalValue(item, `${path}[${index}]`, nextAncestors));
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`${path} must be a plain object.`);
+	const record = value;
+	return Object.fromEntries(Object.keys(record).sort().map((key) => [key, canonicalValue(record[key], `${path}.${key}`, nextAncestors)]));
+}
+/** WASM-OJ canonical JSON: sorted object keys, safe integers, UTF-8, and one trailing newline. */
+function canonicalJsonBytes$1(value) {
+	return encoder.encode(`${JSON.stringify(canonicalValue(value, "$", /* @__PURE__ */ new Set()))}\n`);
+}
+//#endregion
+//#region src/online-judge/contest-public.ts
+var CONTEST_PUBLIC_PROJECTION_SCHEMA = "wasm-oj-platform/contest-public-problem-projection/v1";
+/** The single deterministic hidden-data redaction used by author CI and platform validation. */
+function deriveContestPublic$1(practice) {
+	if (practice.judgeCases.some((testCase) => testCase.kind !== "sample")) throw new TypeError("Practice-public input contains non-sample judge data.");
+	return {
+		...structuredClone(practice),
+		editorial: {
+			"zh-TW": "",
+			en: ""
+		},
+		judgeCases: practice.judgeCases.filter((testCase) => testCase.kind === "sample").map((testCase) => structuredClone(testCase))
+	};
+}
+function createContestPublicProjection(practice) {
+	return {
+		schema: CONTEST_PUBLIC_PROJECTION_SCHEMA,
+		problem: deriveContestPublic$1(practice)
+	};
+}
+function contestPublicProjectionBytes(practice) {
+	return canonicalJsonBytes$1(createContestPublicProjection(practice));
+}
+//#endregion
+//#region src/online-judge/contracts.ts
+var SUBMISSION_SOURCE_LIMITS = Object.freeze({
+	totalBytes: 1048576,
+	maximumFiles: 128,
+	fileBytes: 262144
+});
+var SUBMISSION_VERDICTS = [
+	"accepted",
+	"wrong-answer",
+	"runtime-error",
+	"instruction-limit",
+	"memory-limit",
+	"output-limit",
+	"filesystem-limit",
+	"logical-time-limit",
+	"wall-time-limit",
+	"compile-error",
+	"judge-error",
+	"cancelled"
+];
+var MAX_PROMPT_BYTES = 16384;
+var SHA256$2 = /^[0-9a-f]{64}$/;
+var SLUG$2 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var IDENTIFIER = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+var SOURCE_PATH$1 = /^(?!\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*\\)(?!.*\/$)[^\u0000-\u001f\u007f]+$/;
+var MAX_DURATION_SECONDS = 31622400;
+var MAX_RULE_INTEGER = 1e9;
+var PENALIZED_ICPC_VERDICTS = /* @__PURE__ */ new Set([
+	"wrong-answer",
+	"runtime-error",
+	"instruction-limit",
+	"memory-limit",
+	"output-limit",
+	"filesystem-limit",
+	"logical-time-limit",
+	"wall-time-limit",
+	"compile-error"
+]);
+function record$4(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
+	return value;
+}
+function exact$3(value, keys, label) {
+	const actual = Object.keys(value).sort();
+	const expected = [...keys].sort();
+	if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) throw new TypeError(`${label} has an invalid shape.`);
+}
+function integer(value, label, minimum, maximum = MAX_RULE_INTEGER) {
+	if (!Number.isSafeInteger(value) || value < minimum || value > maximum) throw new TypeError(`${label} must be an integer between ${minimum} and ${maximum}.`);
+	return value;
+}
+function finiteNumber(value, label, minimum, maximum = MAX_RULE_INTEGER) {
+	if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) throw new TypeError(`${label} must be a finite number between ${minimum} and ${maximum}.`);
+	return value;
+}
+function contestSlug(value, label) {
+	if (typeof value !== "string" || value.length > 128 || !SLUG$2.test(value)) throw new TypeError(`${label} is invalid.`);
+	return value;
+}
+function timestamp(value, label) {
+	if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value) || Number.isNaN(Date.parse(value))) throw new TypeError(`${label} must be an RFC 3339 UTC timestamp.`);
+	return value;
+}
+function parseClock(value, label) {
+	const input = record$4(value, label);
+	if (input.kind === "global") {
+		exact$3(input, [
+			"durationSeconds",
+			"kind",
+			"registrationClosesAt",
+			"registrationOpensAt",
+			"startsAt"
+		], label);
+		const registrationOpensAt = timestamp(input.registrationOpensAt, `${label}.registrationOpensAt`);
+		const registrationClosesAt = timestamp(input.registrationClosesAt, `${label}.registrationClosesAt`);
+		const startsAt = timestamp(input.startsAt, `${label}.startsAt`);
+		const durationSeconds = integer(input.durationSeconds, `${label}.durationSeconds`, 1, MAX_DURATION_SECONDS);
+		const opensMs = Date.parse(registrationOpensAt);
+		const closesMs = Date.parse(registrationClosesAt);
+		const startsMs = Date.parse(startsAt);
+		if (opensMs >= closesMs || opensMs > startsMs || closesMs > startsMs + durationSeconds * 1e3) throw new TypeError(`${label} registration window must open no later than start and close before the contest ends.`);
+		return {
+			kind: "global",
+			registrationOpensAt,
+			registrationClosesAt,
+			startsAt,
+			durationSeconds
+		};
+	}
+	if (input.kind === "individual") {
+		exact$3(input, [
+			"durationSeconds",
+			"enrollmentClosesAt",
+			"enrollmentOpensAt",
+			"kind"
+		], label);
+		const enrollmentOpensAt = timestamp(input.enrollmentOpensAt, `${label}.enrollmentOpensAt`);
+		const enrollmentClosesAt = timestamp(input.enrollmentClosesAt, `${label}.enrollmentClosesAt`);
+		if (Date.parse(enrollmentOpensAt) >= Date.parse(enrollmentClosesAt)) throw new TypeError(`${label} enrollment window is invalid.`);
+		return {
+			kind: "individual",
+			enrollmentOpensAt,
+			enrollmentClosesAt,
+			durationSeconds: integer(input.durationSeconds, `${label}.durationSeconds`, 1, MAX_DURATION_SECONDS)
+		};
+	}
+	throw new TypeError(`${label}.kind is invalid.`);
+}
+function parseCompilerPin(value, label) {
+	const input = record$4(value, label);
+	exact$3(input, ["configDigest", "configId"], label);
+	if (typeof input.configId !== "string" || !IDENTIFIER.test(input.configId)) throw new TypeError(`${label}.configId is invalid.`);
+	if (typeof input.configDigest !== "string" || !SHA256$2.test(input.configDigest)) throw new TypeError(`${label}.configDigest must be a lowercase SHA-256 digest.`);
+	return {
+		configId: input.configId,
+		configDigest: input.configDigest
+	};
+}
+function parsePromptLimits(value, label) {
+	const input = record$4(value, label);
+	exact$3(input, [
+		"generatedSourceBytes",
+		"inputTokens",
+		"outputTokens",
+		"promptBytes",
+		"timeoutSeconds"
+	], label);
+	return {
+		promptBytes: integer(input.promptBytes, `${label}.promptBytes`, 1, MAX_PROMPT_BYTES),
+		inputTokens: integer(input.inputTokens, `${label}.inputTokens`, 1, 1e6),
+		outputTokens: integer(input.outputTokens, `${label}.outputTokens`, 1, 1e6),
+		generatedSourceBytes: integer(input.generatedSourceBytes, `${label}.generatedSourceBytes`, 1, SUBMISSION_SOURCE_LIMITS.totalBytes),
+		timeoutSeconds: integer(input.timeoutSeconds, `${label}.timeoutSeconds`, 1, 3600)
+	};
+}
+function parseOfficialTrack(value, label) {
+	const input = record$4(value, label);
+	if (input.kind === "code") {
+		exact$3(input, ["aiAssist", "kind"], label);
+		if (input.aiAssist !== "allowed" && input.aiAssist !== "disabled") throw new TypeError(`${label}.aiAssist is invalid.`);
+		return {
+			kind: "code",
+			aiAssist: input.aiAssist
+		};
+	}
+	if (input.kind === "prompt-program") {
+		exact$3(input, [
+			"attemptPolicy",
+			"compiler",
+			"disclosure",
+			"kind",
+			"limits"
+		], label);
+		const attemptPolicy = record$4(input.attemptPolicy, `${label}.attemptPolicy`);
+		exact$3(attemptPolicy, ["consumeOn", "terminalInfrastructureFailure"], `${label}.attemptPolicy`);
+		if (attemptPolicy.consumeOn !== "model-response-received" || attemptPolicy.terminalInfrastructureFailure !== "release-reservation") throw new TypeError(`${label}.attemptPolicy is unsupported.`);
+		if (input.disclosure !== "private" && input.disclosure !== "best-after-end") throw new TypeError(`${label}.disclosure is invalid.`);
+		return {
+			kind: "prompt-program",
+			compiler: parseCompilerPin(input.compiler, `${label}.compiler`),
+			limits: parsePromptLimits(input.limits, `${label}.limits`),
+			attemptPolicy: {
+				consumeOn: "model-response-received",
+				terminalInfrastructureFailure: "release-reservation"
+			},
+			disclosure: input.disclosure
+		};
+	}
+	throw new TypeError(`${label}.kind is invalid.`);
+}
+function parseOutputProfile(value, label) {
+	const input = record$4(value, label);
+	exact$3(input, [
+		"entry",
+		"language",
+		"optimization",
+		"target"
+	], label);
+	if (typeof input.language !== "string" || !isBuiltinLanguage(input.language)) throw new TypeError(`${label}.language is unsupported.`);
+	if (input.target !== "wasip1" && input.target !== "wasix") throw new TypeError(`${label}.target is unsupported.`);
+	if (input.optimization !== "debug" && input.optimization !== "release") throw new TypeError(`${label}.optimization is unsupported.`);
+	if (typeof input.entry !== "string" || input.entry.length > 512 || !SOURCE_PATH$1.test(input.entry)) throw new TypeError(`${label}.entry is invalid.`);
+	return {
+		language: input.language,
+		target: input.target,
+		optimization: input.optimization,
+		entry: input.entry
+	};
+}
+function parseProblems(value, track, durationSeconds, label) {
+	if (!Array.isArray(value) || value.length < 1 || value.length > 100) throw new TypeError(`${label} must contain between 1 and 100 problems.`);
+	const slugs = /* @__PURE__ */ new Set();
+	const batchCounts = /* @__PURE__ */ new Map();
+	const batchReleases = /* @__PURE__ */ new Map();
+	return value.map((candidate, index) => {
+		const problemLabel = `${label}[${index}]`;
+		const input = record$4(candidate, problemLabel);
+		exact$3(input, track.kind === "code" ? [
+			"attemptLimit",
+			"batch",
+			"points",
+			"releaseAfterSeconds",
+			"slug",
+			"submissionClosesAfterSeconds"
+		] : [
+			"attemptLimit",
+			"batch",
+			"output",
+			"points",
+			"releaseAfterSeconds",
+			"slug",
+			"submissionClosesAfterSeconds"
+		], problemLabel);
+		const slug = contestSlug(input.slug, `${problemLabel}.slug`);
+		if (slugs.has(slug)) throw new TypeError(`${label} contains duplicate problem '${slug}'.`);
+		slugs.add(slug);
+		const batch = integer(input.batch, `${problemLabel}.batch`, 1, 100);
+		const releaseAfterSeconds = integer(input.releaseAfterSeconds, `${problemLabel}.releaseAfterSeconds`, 0, durationSeconds);
+		const submissionClosesAfterSeconds = integer(input.submissionClosesAfterSeconds, `${problemLabel}.submissionClosesAfterSeconds`, 0, durationSeconds);
+		if (submissionClosesAfterSeconds <= releaseAfterSeconds) throw new TypeError(`${problemLabel} submission window is empty.`);
+		const batchCount = (batchCounts.get(batch) ?? 0) + 1;
+		if (batchCount > 8) throw new TypeError(`${label} batch ${batch} exceeds 8 problems.`);
+		batchCounts.set(batch, batchCount);
+		const existingRelease = batchReleases.get(batch);
+		if (existingRelease !== void 0 && existingRelease !== releaseAfterSeconds) throw new TypeError(`${label} batch ${batch} has inconsistent release offsets.`);
+		batchReleases.set(batch, releaseAfterSeconds);
+		const base = {
+			slug,
+			batch,
+			releaseAfterSeconds,
+			submissionClosesAfterSeconds,
+			points: finiteNumber(input.points, `${problemLabel}.points`, Number.EPSILON),
+			attemptLimit: integer(input.attemptLimit, `${problemLabel}.attemptLimit`, 1, 1e6)
+		};
+		if (track.kind === "code") return base;
+		return {
+			...base,
+			output: parseOutputProfile(input.output, `${problemLabel}.output`)
+		};
+	});
+}
+function uniqueEnum(value, allowed, label) {
+	if (!Array.isArray(value)) throw new TypeError(`${label} must be an array.`);
+	const result = value.map((candidate, index) => {
+		if (typeof candidate !== "string" || !allowed.has(candidate)) throw new TypeError(`${label}[${index}] is invalid.`);
+		return candidate;
+	});
+	if (new Set(result).size !== result.length) throw new TypeError(`${label} contains a duplicate.`);
+	return result;
+}
+var SCORE_TIE_BREAKS = /* @__PURE__ */ new Set([
+	"fully-passed-cases",
+	"deterministic-cost",
+	"peak-memory",
+	"final-best-achieved-at"
+]);
+var ICPC_TIE_BREAKS = /* @__PURE__ */ new Set([
+	"last-solve-at",
+	"deterministic-cost",
+	"peak-memory"
+]);
+var PROGRESS_TIE_BREAKS = /* @__PURE__ */ new Set([
+	"fully-passed-cases",
+	"deterministic-cost",
+	"peak-memory",
+	"final-best-achieved-at"
+]);
+function parseScoring$1(value, label) {
+	const input = record$4(value, label);
+	if (input.kind === "score") {
+		exact$3(input, ["kind", "tieBreaks"], label);
+		return {
+			kind: "score",
+			tieBreaks: uniqueEnum(input.tieBreaks, SCORE_TIE_BREAKS, `${label}.tieBreaks`)
+		};
+	}
+	if (input.kind === "icpc") {
+		exact$3(input, [
+			"kind",
+			"penalizedVerdicts",
+			"tieBreaks",
+			"wrongAttemptPenaltyMinutes"
+		], label);
+		const penalizedVerdicts = uniqueEnum(input.penalizedVerdicts, new Set(SUBMISSION_VERDICTS), `${label}.penalizedVerdicts`);
+		if (penalizedVerdicts.some((verdict) => !PENALIZED_ICPC_VERDICTS.has(verdict))) throw new TypeError(`${label}.penalizedVerdicts may contain only contestant-fault verdicts.`);
+		return {
+			kind: "icpc",
+			wrongAttemptPenaltyMinutes: integer(input.wrongAttemptPenaltyMinutes, `${label}.wrongAttemptPenaltyMinutes`, 0, 10080),
+			penalizedVerdicts,
+			tieBreaks: uniqueEnum(input.tieBreaks, ICPC_TIE_BREAKS, `${label}.tieBreaks`)
+		};
+	}
+	if (input.kind === "progress") {
+		exact$3(input, ["kind", "tieBreaks"], label);
+		return {
+			kind: "progress",
+			tieBreaks: uniqueEnum(input.tieBreaks, PROGRESS_TIE_BREAKS, `${label}.tieBreaks`)
+		};
+	}
+	throw new TypeError(`${label}.kind is invalid.`);
+}
+function parseLeaderboard(value, clock, label) {
+	const input = record$4(value, label);
+	if (input.kind === "live" || input.kind === "hidden-until-end") {
+		exact$3(input, ["kind"], label);
+		return { kind: input.kind };
+	}
+	if (input.kind === "freeze") {
+		exact$3(input, ["atSeconds", "kind"], label);
+		if (clock.kind !== "global") throw new TypeError(`${label} freeze is only valid for a global clock.`);
+		return {
+			kind: "freeze",
+			atSeconds: integer(input.atSeconds, `${label}.atSeconds`, 1, clock.durationSeconds - 1)
+		};
+	}
+	throw new TypeError(`${label}.kind is invalid.`);
+}
+function scopedProblems(scope, atSeconds, problems) {
+	if (scope.kind === "all-released") return problems.filter((problem) => problem.releaseAfterSeconds <= atSeconds);
+	if (scope.kind === "batch") return problems.filter((problem) => problem.batch === scope.batch);
+	const requested = new Set(scope.slugs);
+	return problems.filter((problem) => requested.has(problem.slug));
+}
+function parseCheckpoint(value, label) {
+	const input = record$4(value, label);
+	exact$3(input, [
+		"atSeconds",
+		"id",
+		"ranking",
+		"scope",
+		"settlement",
+		"threshold"
+	], label);
+	const scopeInput = record$4(input.scope, `${label}.scope`);
+	let scope;
+	if (scopeInput.kind === "all-released") {
+		exact$3(scopeInput, ["kind"], `${label}.scope`);
+		scope = { kind: "all-released" };
+	} else if (scopeInput.kind === "batch") {
+		exact$3(scopeInput, ["batch", "kind"], `${label}.scope`);
+		scope = {
+			kind: "batch",
+			batch: integer(scopeInput.batch, `${label}.scope.batch`, 1, 100)
+		};
+	} else if (scopeInput.kind === "problems") {
+		exact$3(scopeInput, ["kind", "slugs"], `${label}.scope`);
+		if (!Array.isArray(scopeInput.slugs) || scopeInput.slugs.length < 1 || scopeInput.slugs.length > 100) throw new TypeError(`${label}.scope.slugs is invalid.`);
+		const slugs = scopeInput.slugs.map((slug, index) => contestSlug(slug, `${label}.scope.slugs[${index}]`));
+		if (new Set(slugs).size !== slugs.length) throw new TypeError(`${label}.scope.slugs contains a duplicate.`);
+		scope = {
+			kind: "problems",
+			slugs
+		};
+	} else throw new TypeError(`${label}.scope.kind is invalid.`);
+	const thresholdInput = record$4(input.threshold, `${label}.threshold`);
+	exact$3(thresholdInput, ["minimumScore", "minimumSolved"], `${label}.threshold`);
+	const minimumSolved = thresholdInput.minimumSolved === null ? null : integer(thresholdInput.minimumSolved, `${label}.threshold.minimumSolved`, 0, 100);
+	const minimumScore = thresholdInput.minimumScore === null ? null : finiteNumber(thresholdInput.minimumScore, `${label}.threshold.minimumScore`, 0);
+	if (minimumSolved === null && minimumScore === null) throw new TypeError(`${label}.threshold must declare at least one minimum.`);
+	let ranking;
+	if (input.ranking === null) ranking = null;
+	else {
+		const rankInput = record$4(input.ranking, `${label}.ranking`);
+		if (rankInput.kind === "top-k") {
+			exact$3(rankInput, ["count", "kind"], `${label}.ranking`);
+			ranking = {
+				kind: "top-k",
+				count: integer(rankInput.count, `${label}.ranking.count`, 1, MAX_RULE_INTEGER)
+			};
+		} else if (rankInput.kind === "top-percent") {
+			exact$3(rankInput, ["kind", "percent"], `${label}.ranking`);
+			ranking = {
+				kind: "top-percent",
+				percent: finiteNumber(rankInput.percent, `${label}.ranking.percent`, Number.EPSILON, 100)
+			};
+		} else throw new TypeError(`${label}.ranking.kind is invalid.`);
+	}
+	if (input.settlement !== "provisional" && input.settlement !== "pause-until-terminal") throw new TypeError(`${label}.settlement is invalid.`);
+	return {
+		id: contestSlug(input.id, `${label}.id`),
+		atSeconds: integer(input.atSeconds, `${label}.atSeconds`, 0, MAX_DURATION_SECONDS),
+		scope,
+		threshold: {
+			minimumSolved,
+			minimumScore
+		},
+		ranking,
+		settlement: input.settlement
+	};
+}
+function parsePresetProblemSlugs(value, label) {
+	if (!Array.isArray(value) || value.length < 1 || value.length > 100) throw new TypeError(`${label} must contain between 1 and 100 problem slugs.`);
+	const slugs = value.map((candidate, index) => contestSlug(candidate, `${label}[${index}]`));
+	if (new Set(slugs).size !== slugs.length) throw new TypeError(`${label} contains a duplicate.`);
+	return slugs;
+}
+function parseAiAssist(value, label) {
+	if (value !== "allowed" && value !== "disabled") throw new TypeError(`${label} is invalid.`);
+	return value;
+}
+function parsePresetLeaderboard(value, clockValue, label) {
+	return parseLeaderboard(value, parseClock(clockValue, `${label} clock`), label);
+}
+function parseContestRules(value, label = "contest rules") {
+	const input = record$4(value, label);
+	exact$3(input, [
+		"checkpoints",
+		"clock",
+		"evidenceAt",
+		"leaderboard",
+		"officialTrack",
+		"problems",
+		"scoring"
+	], label);
+	const clock = parseClock(input.clock, `${label}.clock`);
+	const officialTrack = parseOfficialTrack(input.officialTrack, `${label}.officialTrack`);
+	if (input.evidenceAt !== "input-admitted" && input.evidenceAt !== "generated-source-ready" && input.evidenceAt !== "judge-terminal") throw new TypeError(`${label}.evidenceAt is invalid.`);
+	if (input.evidenceAt === "generated-source-ready" && officialTrack.kind !== "prompt-program") throw new TypeError(`${label}.evidenceAt generated-source-ready requires the prompt-program track.`);
+	const evidenceAt = input.evidenceAt;
+	const problems = parseProblems(input.problems, officialTrack, clock.durationSeconds, `${label}.problems`);
+	const scoring = parseScoring$1(input.scoring, `${label}.scoring`);
+	if (!Array.isArray(input.checkpoints) || input.checkpoints.length > 100) throw new TypeError(`${label}.checkpoints is invalid.`);
+	const checkpoints = input.checkpoints.map((checkpoint, index) => parseCheckpoint(checkpoint, `${label}.checkpoints[${index}]`));
+	if (scoring.kind === "progress" && checkpoints.length < 1) throw new TypeError(`${label}.scoring progress requires at least one checkpoint.`);
+	const checkpointIds = /* @__PURE__ */ new Set();
+	let priorCheckpointAt = -1;
+	for (const checkpoint of checkpoints) {
+		if (checkpointIds.has(checkpoint.id)) throw new TypeError(`${label}.checkpoints contains duplicate id '${checkpoint.id}'.`);
+		checkpointIds.add(checkpoint.id);
+		if (checkpoint.atSeconds <= priorCheckpointAt || checkpoint.atSeconds > clock.durationSeconds) throw new TypeError(`${label}.checkpoints must have strictly increasing offsets within the contest duration.`);
+		priorCheckpointAt = checkpoint.atSeconds;
+		if (clock.kind === "individual" && (checkpoint.ranking !== null || checkpoint.settlement !== "provisional")) throw new TypeError(`${label}.checkpoints for an individual clock must be provisional and cannot rank entrants.`);
+		const scoped = scopedProblems(checkpoint.scope, checkpoint.atSeconds, problems);
+		if (scoped.length < 1 || scoped.some((problem) => problem.releaseAfterSeconds > checkpoint.atSeconds)) throw new TypeError(`${label}.checkpoint '${checkpoint.id}' scope must contain released problems.`);
+		if (checkpoint.scope.kind === "problems" && scoped.length !== checkpoint.scope.slugs.length) throw new TypeError(`${label}.checkpoint '${checkpoint.id}' references an unknown problem.`);
+		if (checkpoint.threshold.minimumSolved !== null && checkpoint.threshold.minimumSolved > scoped.length) throw new TypeError(`${label}.checkpoint '${checkpoint.id}' minimumSolved exceeds its scope.`);
+		const maximumScore = scoped.reduce((total, problem) => total + problem.points, 0);
+		if (checkpoint.threshold.minimumScore !== null && checkpoint.threshold.minimumScore > maximumScore) throw new TypeError(`${label}.checkpoint '${checkpoint.id}' minimumScore exceeds its scope.`);
+	}
+	const base = {
+		clock,
+		evidenceAt,
+		scoring,
+		checkpoints,
+		leaderboard: parseLeaderboard(input.leaderboard, clock, `${label}.leaderboard`)
+	};
+	return officialTrack.kind === "code" ? {
+		...base,
+		officialTrack,
+		problems
+	} : {
+		...base,
+		officialTrack,
+		problems
+	};
+}
+function parseContestRulesPreset(value, label = "contest rules preset") {
+	const input = record$4(value, label);
+	const preset = input.preset;
+	if (preset === "classic-score") {
+		exact$3(input, [
+			"aiAssist",
+			"attemptLimit",
+			"clock",
+			"leaderboard",
+			"pointsPerProblem",
+			"preset",
+			"problemSlugs"
+		], label);
+		return {
+			preset,
+			clock: parseClock(input.clock, `${label}.clock`),
+			problemSlugs: parsePresetProblemSlugs(input.problemSlugs, `${label}.problemSlugs`),
+			pointsPerProblem: finiteNumber(input.pointsPerProblem, `${label}.pointsPerProblem`, Number.EPSILON),
+			attemptLimit: integer(input.attemptLimit, `${label}.attemptLimit`, 1, 1e6),
+			aiAssist: parseAiAssist(input.aiAssist, `${label}.aiAssist`),
+			leaderboard: parsePresetLeaderboard(input.leaderboard, input.clock, `${label}.leaderboard`)
+		};
+	}
+	if (preset === "icpc") {
+		exact$3(input, [
+			"aiAssist",
+			"attemptLimit",
+			"clock",
+			"leaderboard",
+			"penalizedVerdicts",
+			"preset",
+			"problemSlugs",
+			"wrongAttemptPenaltyMinutes"
+		], label);
+		const penalizedVerdicts = uniqueEnum(input.penalizedVerdicts, new Set(SUBMISSION_VERDICTS), `${label}.penalizedVerdicts`);
+		if (penalizedVerdicts.some((verdict) => !PENALIZED_ICPC_VERDICTS.has(verdict))) throw new TypeError(`${label}.penalizedVerdicts is invalid.`);
+		return {
+			preset,
+			clock: parseClock(input.clock, `${label}.clock`),
+			problemSlugs: parsePresetProblemSlugs(input.problemSlugs, `${label}.problemSlugs`),
+			attemptLimit: integer(input.attemptLimit, `${label}.attemptLimit`, 1, 1e6),
+			aiAssist: parseAiAssist(input.aiAssist, `${label}.aiAssist`),
+			wrongAttemptPenaltyMinutes: integer(input.wrongAttemptPenaltyMinutes, `${label}.wrongAttemptPenaltyMinutes`, 0, 10080),
+			penalizedVerdicts,
+			leaderboard: parsePresetLeaderboard(input.leaderboard, input.clock, `${label}.leaderboard`)
+		};
+	}
+	if (preset === "blitz-batches") {
+		exact$3(input, [
+			"aiAssist",
+			"attemptLimit",
+			"batchSize",
+			"clock",
+			"leaderboard",
+			"minimumSolvedPerBatch",
+			"pointsPerProblem",
+			"preset",
+			"problemSlugs",
+			"releaseIntervalSeconds"
+		], label);
+		const problemSlugs = parsePresetProblemSlugs(input.problemSlugs, `${label}.problemSlugs`);
+		const batchSize = integer(input.batchSize, `${label}.batchSize`, 1, 8);
+		return {
+			preset,
+			clock: parseClock(input.clock, `${label}.clock`),
+			problemSlugs,
+			batchSize,
+			releaseIntervalSeconds: integer(input.releaseIntervalSeconds, `${label}.releaseIntervalSeconds`, 1, MAX_DURATION_SECONDS),
+			pointsPerProblem: finiteNumber(input.pointsPerProblem, `${label}.pointsPerProblem`, Number.EPSILON),
+			attemptLimit: integer(input.attemptLimit, `${label}.attemptLimit`, 1, 1e6),
+			minimumSolvedPerBatch: integer(input.minimumSolvedPerBatch, `${label}.minimumSolvedPerBatch`, 0, Math.min(batchSize, problemSlugs.length)),
+			aiAssist: parseAiAssist(input.aiAssist, `${label}.aiAssist`),
+			leaderboard: parsePresetLeaderboard(input.leaderboard, input.clock, `${label}.leaderboard`)
+		};
+	}
+	if (preset === "prompt-five-by-three") {
+		exact$3(input, [
+			"clock",
+			"compiler",
+			"disclosure",
+			"leaderboard",
+			"limits",
+			"preset",
+			"problems"
+		], label);
+		if (!Array.isArray(input.problems) || input.problems.length !== 5) throw new TypeError(`${label}.problems must contain exactly five problems.`);
+		const problems = input.problems.map((candidate, index) => {
+			const problem = record$4(candidate, `${label}.problems[${index}]`);
+			exact$3(problem, ["output", "slug"], `${label}.problems[${index}]`);
+			return {
+				slug: contestSlug(problem.slug, `${label}.problems[${index}].slug`),
+				output: parseOutputProfile(problem.output, `${label}.problems[${index}].output`)
+			};
+		});
+		if (new Set(problems.map((problem) => problem.slug)).size !== problems.length) throw new TypeError(`${label}.problems contains a duplicate.`);
+		if (input.disclosure !== "private" && input.disclosure !== "best-after-end") throw new TypeError(`${label}.disclosure is invalid.`);
+		return {
+			preset,
+			clock: parseClock(input.clock, `${label}.clock`),
+			problems,
+			compiler: parseCompilerPin(input.compiler, `${label}.compiler`),
+			limits: parsePromptLimits(input.limits, `${label}.limits`),
+			disclosure: input.disclosure,
+			leaderboard: parsePresetLeaderboard(input.leaderboard, input.clock, `${label}.leaderboard`)
+		};
+	}
+	throw new TypeError(`${label}.preset is invalid.`);
+}
+function expandContestRulesPreset(preset) {
+	const close = preset.clock.durationSeconds;
+	if (preset.preset === "classic-score") return parseContestRules({
+		clock: preset.clock,
+		officialTrack: {
+			kind: "code",
+			aiAssist: preset.aiAssist
+		},
+		evidenceAt: "input-admitted",
+		problems: preset.problemSlugs.map((slug) => ({
+			slug,
+			batch: 1,
+			releaseAfterSeconds: 0,
+			submissionClosesAfterSeconds: close,
+			points: preset.pointsPerProblem,
+			attemptLimit: preset.attemptLimit
+		})),
+		scoring: {
+			kind: "score",
+			tieBreaks: [
+				"fully-passed-cases",
+				"deterministic-cost",
+				"peak-memory",
+				"final-best-achieved-at"
+			]
+		},
+		checkpoints: [],
+		leaderboard: preset.leaderboard
+	});
+	if (preset.preset === "icpc") return parseContestRules({
+		clock: preset.clock,
+		officialTrack: {
+			kind: "code",
+			aiAssist: preset.aiAssist
+		},
+		evidenceAt: "judge-terminal",
+		problems: preset.problemSlugs.map((slug) => ({
+			slug,
+			batch: 1,
+			releaseAfterSeconds: 0,
+			submissionClosesAfterSeconds: close,
+			points: 100,
+			attemptLimit: preset.attemptLimit
+		})),
+		scoring: {
+			kind: "icpc",
+			wrongAttemptPenaltyMinutes: preset.wrongAttemptPenaltyMinutes,
+			penalizedVerdicts: preset.penalizedVerdicts,
+			tieBreaks: []
+		},
+		checkpoints: [],
+		leaderboard: preset.leaderboard
+	});
+	if (preset.preset === "blitz-batches") {
+		const batchCount = Math.ceil(preset.problemSlugs.length / preset.batchSize);
+		const checkpoints = Array.from({ length: Math.max(0, batchCount - 1) }, (_, index) => ({
+			id: `batch-${index + 1}`,
+			atSeconds: (index + 1) * preset.releaseIntervalSeconds,
+			scope: {
+				kind: "batch",
+				batch: index + 1
+			},
+			threshold: {
+				minimumSolved: preset.minimumSolvedPerBatch,
+				minimumScore: null
+			},
+			ranking: null,
+			settlement: "provisional"
+		}));
+		return parseContestRules({
+			clock: preset.clock,
+			officialTrack: {
+				kind: "code",
+				aiAssist: preset.aiAssist
+			},
+			evidenceAt: "judge-terminal",
+			problems: preset.problemSlugs.map((slug, index) => ({
+				slug,
+				batch: Math.floor(index / preset.batchSize) + 1,
+				releaseAfterSeconds: Math.floor(index / preset.batchSize) * preset.releaseIntervalSeconds,
+				submissionClosesAfterSeconds: close,
+				points: preset.pointsPerProblem,
+				attemptLimit: preset.attemptLimit
+			})),
+			scoring: {
+				kind: "progress",
+				tieBreaks: [
+					"fully-passed-cases",
+					"deterministic-cost",
+					"final-best-achieved-at"
+				]
+			},
+			checkpoints,
+			leaderboard: preset.leaderboard
+		});
+	}
+	return parseContestRules({
+		clock: preset.clock,
+		officialTrack: {
+			kind: "prompt-program",
+			compiler: preset.compiler,
+			limits: preset.limits,
+			attemptPolicy: {
+				consumeOn: "model-response-received",
+				terminalInfrastructureFailure: "release-reservation"
+			},
+			disclosure: preset.disclosure
+		},
+		evidenceAt: "generated-source-ready",
+		problems: preset.problems.map((problem) => ({
+			...problem,
+			batch: 1,
+			releaseAfterSeconds: 0,
+			submissionClosesAfterSeconds: close,
+			points: 100,
+			attemptLimit: 3
+		})),
+		scoring: {
+			kind: "score",
+			tieBreaks: ["deterministic-cost", "final-best-achieved-at"]
+		},
+		checkpoints: [],
+		leaderboard: preset.leaderboard
+	});
+}
+function logicalContestSeconds(snapshot, now, durationSeconds) {
+	integer(snapshot.generation, "contest clock generation", 1);
+	const duration = integer(durationSeconds, "contest durationSeconds", 1, MAX_DURATION_SECONDS);
+	const capturedAt = timestamp(snapshot.capturedAt, "contest clock capturedAt");
+	const nowTimestamp = timestamp(now, "contest clock now");
+	if (snapshot.state !== "running" && snapshot.state !== "paused") throw new TypeError("contest clock state is invalid.");
+	if (typeof snapshot.logicalSeconds !== "number" || !Number.isFinite(snapshot.logicalSeconds)) throw new TypeError("contest clock logicalSeconds is invalid.");
+	const projected = snapshot.state === "paused" ? snapshot.logicalSeconds : snapshot.logicalSeconds + (Date.parse(nowTimestamp) - Date.parse(capturedAt)) / 1e3;
+	return Math.min(duration, Math.max(0, projected));
+}
+function projectContestRules(input) {
+	const { rules, clock, entrant } = input;
+	const observedAt = timestamp(input.observedAt, "contest projection observedAt");
+	const scheduleShiftSeconds = integer(input.scheduleShiftSeconds ?? 0, "contest projection scheduleShiftSeconds", 0);
+	const observedMs = Date.parse(observedAt) - scheduleShiftSeconds * 1e3;
+	if (clock !== null && (!Number.isSafeInteger(clock.generation) || clock.generation < 1)) throw new TypeError("contest clock generation is invalid.");
+	let phase;
+	let logicalSeconds = clock === null ? null : logicalContestSeconds(clock, observedAt, rules.clock.durationSeconds);
+	if (input.contestEnded === true || entrant?.completed === true) phase = "ended";
+	else if (entrant === null || !entrant.joined) {
+		const opensAt = rules.clock.kind === "global" ? rules.clock.registrationOpensAt : rules.clock.enrollmentOpensAt;
+		const closesAt = rules.clock.kind === "global" ? rules.clock.registrationClosesAt : rules.clock.enrollmentClosesAt;
+		if (observedMs >= Date.parse(opensAt) && observedMs < Date.parse(closesAt)) phase = "registration";
+		else if (rules.clock.kind === "global" && observedMs >= Date.parse(rules.clock.startsAt) + rules.clock.durationSeconds * 1e3) phase = "ended";
+		else phase = "upcoming";
+	} else if (entrant.eliminatedAtSeconds !== null) {
+		phase = "eliminated";
+		logicalSeconds ??= entrant.eliminatedAtSeconds;
+	} else if (clock?.state === "paused") phase = "paused";
+	else if (rules.clock.kind === "individual" && !entrant.started) phase = "awaiting-start";
+	else if (clock === null) phase = "upcoming";
+	else if (logicalSeconds !== null && logicalSeconds >= rules.clock.durationSeconds) phase = "ended";
+	else phase = "running";
+	const attempted = (slug) => {
+		const count = input.attemptedByProblem[slug] ?? 0;
+		if (!Number.isSafeInteger(count) || count < 0) throw new TypeError(`attempt count for '${slug}' is invalid.`);
+		return count;
+	};
+	const problems = rules.problems.map((problem) => {
+		let availability;
+		if (entrant === null || !entrant.joined || logicalSeconds === null || logicalSeconds < problem.releaseAfterSeconds) availability = "locked";
+		else if (phase === "eliminated" || logicalSeconds >= problem.submissionClosesAfterSeconds || phase === "ended") availability = "closed";
+		else availability = "open";
+		return {
+			slug: problem.slug,
+			availability,
+			releaseAfterSeconds: problem.releaseAfterSeconds,
+			submissionClosesAfterSeconds: problem.submissionClosesAfterSeconds,
+			attemptsRemaining: Math.max(0, problem.attemptLimit - attempted(problem.slug))
+		};
+	});
+	let nextBoundarySeconds = null;
+	if (logicalSeconds !== null && phase !== "ended" && phase !== "eliminated") {
+		const candidates = [
+			rules.clock.durationSeconds,
+			...rules.problems.flatMap((problem) => [problem.releaseAfterSeconds, problem.submissionClosesAfterSeconds]),
+			...rules.checkpoints.map((checkpoint) => checkpoint.atSeconds),
+			...rules.leaderboard.kind === "freeze" ? [rules.leaderboard.atSeconds] : []
+		].filter((boundary) => boundary > logicalSeconds);
+		nextBoundarySeconds = candidates.length === 0 ? null : Math.min(...candidates);
+	}
+	return {
+		generation: clock?.generation ?? 0,
+		phase,
+		logicalSeconds,
+		nextBoundarySeconds,
+		problems
+	};
+}
+function decideContestAdmission(input, problemSlug) {
+	const problem = input.rules.problems.find((candidate) => candidate.slug === problemSlug);
+	if (!problem) return {
+		allowed: false,
+		reason: "unknown-problem"
+	};
+	if (input.entrant === null || !input.entrant.joined) return {
+		allowed: false,
+		reason: "not-joined"
+	};
+	if (input.rules.clock.kind === "individual" && !input.entrant.started) return {
+		allowed: false,
+		reason: "not-started"
+	};
+	if (input.clock?.state === "paused") return {
+		allowed: false,
+		reason: "paused"
+	};
+	if (input.entrant.eliminatedAtSeconds !== null) return {
+		allowed: false,
+		reason: "eliminated"
+	};
+	const projectedProblem = projectContestRules(input).problems.find((candidate) => candidate.slug === problemSlug);
+	if (projectedProblem.availability === "locked") return {
+		allowed: false,
+		reason: "problem-locked"
+	};
+	if (projectedProblem.availability === "closed") return {
+		allowed: false,
+		reason: "problem-closed"
+	};
+	if (projectedProblem.attemptsRemaining < 1) return {
+		allowed: false,
+		reason: "attempt-limit"
+	};
+	return {
+		allowed: true,
+		problem
+	};
+}
+function compareNumber(left, right, direction) {
+	return direction === "asc" ? left - right : right - left;
+}
+function compareFactMetric(left, right, tieBreak) {
+	switch (tieBreak) {
+		case "fully-passed-cases": return compareNumber(left.fullyPassedCases, right.fullyPassedCases, "desc");
+		case "deterministic-cost": return compareNumber(left.deterministicCost, right.deterministicCost, "asc");
+		case "peak-memory": return compareNumber(left.peakMemoryBytes, right.peakMemoryBytes, "asc");
+		case "final-best-achieved-at": return compareNumber(left.logicalSeconds, right.logicalSeconds, "asc");
+	}
+}
+function bestScoreFact(facts, tieBreaks) {
+	let selected = null;
+	for (const fact of facts) {
+		if (!fact.eligible) continue;
+		if (selected === null) {
+			selected = fact;
+			continue;
+		}
+		let comparison = compareNumber(fact.score, selected.score, "desc");
+		for (const tieBreak of tieBreaks) {
+			if (comparison !== 0) break;
+			comparison = compareFactMetric(fact, selected, tieBreak);
+		}
+		if (comparison < 0 || comparison === 0 && fact.logicalSeconds < selected.logicalSeconds) selected = fact;
+	}
+	return selected;
+}
+function validateResultFacts(rules, entrantIds, results) {
+	if (new Set(entrantIds).size !== entrantIds.length || entrantIds.some((entrantId) => !entrantId)) throw new TypeError("entrantIds must be unique non-empty strings.");
+	const entrants = new Set(entrantIds);
+	const problems = new Set(rules.problems.map((problem) => problem.slug));
+	for (const result of results) {
+		if (!entrants.has(result.entrantId)) throw new TypeError(`result references unknown entrant '${result.entrantId}'.`);
+		if (!problems.has(result.problemSlug)) throw new TypeError(`result references unknown problem '${result.problemSlug}'.`);
+		if (!SUBMISSION_VERDICTS.includes(result.verdict)) throw new TypeError("result verdict is invalid.");
+		finiteNumber(result.score, "result score", 0, 100);
+		integer(result.fullyPassedCases, "result fullyPassedCases", 0);
+		integer(result.deterministicCost, "result deterministicCost", 0);
+		integer(result.peakMemoryBytes, "result peakMemoryBytes", 0);
+		finiteNumber(result.logicalSeconds, "result logicalSeconds", 0, rules.clock.durationSeconds);
+		if (typeof result.eligible !== "boolean") throw new TypeError("result eligible must be boolean.");
+	}
+}
+function standingMetric(standing, tieBreak) {
+	switch (tieBreak) {
+		case "fully-passed-cases": return standing.fullyPassedCases;
+		case "deterministic-cost": return standing.deterministicCost;
+		case "peak-memory": return standing.peakMemoryBytes;
+		case "final-best-achieved-at":
+		case "last-solve-at": return standing.achievedAtSeconds;
+	}
+}
+function compareStandingMetric(left, right, tieBreak) {
+	const direction = tieBreak === "fully-passed-cases" ? "desc" : "asc";
+	return compareNumber(standingMetric(left, tieBreak), standingMetric(right, tieBreak), direction);
+}
+function compareCompetitiveStandings(scoring, left, right) {
+	if (scoring.kind === "icpc") {
+		let comparison = compareNumber(left.solved, right.solved, "desc") || compareNumber(left.penaltyMinutes, right.penaltyMinutes, "asc");
+		for (const tieBreak of scoring.tieBreaks) {
+			if (comparison !== 0) break;
+			comparison = compareStandingMetric(left, right, tieBreak);
+		}
+		return comparison;
+	}
+	let comparison = scoring.kind === "progress" ? compareNumber(left.furthestCheckpoint, right.furthestCheckpoint, "desc") || compareNumber(left.solved, right.solved, "desc") || compareNumber(left.score, right.score, "desc") : compareNumber(left.score, right.score, "desc");
+	for (const tieBreak of scoring.tieBreaks) {
+		if (comparison !== 0) break;
+		comparison = compareStandingMetric(left, right, tieBreak);
+	}
+	return comparison;
+}
+function rankContestResults(rules, entrantIds, results, passedCheckpointCounts) {
+	validateResultFacts(rules, entrantIds, results);
+	const factsByEntrant = /* @__PURE__ */ new Map();
+	for (const entrantId of entrantIds) factsByEntrant.set(entrantId, []);
+	for (const result of results) factsByEntrant.get(result.entrantId).push(result);
+	const unranked = entrantIds.map((entrantId) => {
+		const entrantFacts = factsByEntrant.get(entrantId);
+		let solved = 0;
+		let score = 0;
+		let penaltyMinutes = 0;
+		let fullyPassedCases = 0;
+		let deterministicCost = 0;
+		let peakMemoryBytes = 0;
+		let achievedAtSeconds = 0;
+		if (rules.scoring.kind === "icpc") {
+			const penalized = new Set(rules.scoring.penalizedVerdicts);
+			for (const problem of rules.problems) {
+				const chronological = entrantFacts.filter((fact) => fact.problemSlug === problem.slug && fact.eligible).sort((left, right) => left.logicalSeconds - right.logicalSeconds);
+				let wrongAttempts = 0;
+				for (const fact of chronological) {
+					if (fact.score === 100) {
+						solved += 1;
+						score += problem.points;
+						penaltyMinutes += Math.floor(fact.logicalSeconds / 60) + wrongAttempts * rules.scoring.wrongAttemptPenaltyMinutes;
+						fullyPassedCases += fact.fullyPassedCases;
+						deterministicCost += fact.deterministicCost;
+						peakMemoryBytes = Math.max(peakMemoryBytes, fact.peakMemoryBytes);
+						achievedAtSeconds = Math.max(achievedAtSeconds, fact.logicalSeconds);
+						break;
+					}
+					if (penalized.has(fact.verdict)) wrongAttempts += 1;
+				}
+			}
+		} else {
+			const tieBreaks = rules.scoring.tieBreaks;
+			for (const problem of rules.problems) {
+				const selected = bestScoreFact(entrantFacts.filter((fact) => fact.problemSlug === problem.slug), tieBreaks);
+				if (!selected) continue;
+				score += problem.points * selected.score / 100;
+				if (selected.score === 100) solved += 1;
+				fullyPassedCases += selected.fullyPassedCases;
+				deterministicCost += selected.deterministicCost;
+				peakMemoryBytes = Math.max(peakMemoryBytes, selected.peakMemoryBytes);
+				achievedAtSeconds = Math.max(achievedAtSeconds, selected.logicalSeconds);
+			}
+		}
+		const furthestCheckpoint = passedCheckpointCounts?.[entrantId] ?? 0;
+		integer(furthestCheckpoint, `passed checkpoint count for '${entrantId}'`, 0, rules.checkpoints.length);
+		return {
+			entrantId,
+			rank: 0,
+			solved,
+			score,
+			penaltyMinutes,
+			furthestCheckpoint,
+			fullyPassedCases,
+			deterministicCost,
+			peakMemoryBytes,
+			achievedAtSeconds
+		};
+	});
+	unranked.sort((left, right) => compareCompetitiveStandings(rules.scoring, left, right) || left.entrantId.localeCompare(right.entrantId));
+	let rank = 1;
+	return unranked.map((standing, index) => {
+		if (index > 0 && compareCompetitiveStandings(rules.scoring, unranked[index - 1], standing) !== 0) rank = index + 1;
+		return {
+			...standing,
+			rank
+		};
+	});
+}
+function evaluateContestCheckpoint(rules, checkpoint, standings, candidates) {
+	if (rules.clock.kind === "individual" && checkpoint.ranking !== null) throw new TypeError("individual checkpoints cannot rank entrants.");
+	if (checkpoint.settlement === "pause-until-terminal" && candidates.some((candidate) => candidate.pending)) throw new TypeError("pause-until-terminal checkpoint cannot settle while bounded work is pending.");
+	const standingByEntrant = new Map(standings.map((standing) => [standing.entrantId, standing]));
+	if (standingByEntrant.size !== standings.length) throw new TypeError("checkpoint standings contain a duplicate entrant.");
+	const candidateIds = /* @__PURE__ */ new Set();
+	for (const candidate of candidates) {
+		if (!candidate.entrantId || candidateIds.has(candidate.entrantId)) throw new TypeError("checkpoint candidates must have unique entrant ids.");
+		candidateIds.add(candidate.entrantId);
+		if (!standingByEntrant.has(candidate.entrantId)) throw new TypeError(`checkpoint candidate '${candidate.entrantId}' has no standing.`);
+		integer(candidate.solved, `checkpoint candidate '${candidate.entrantId}' solved`, 0, 100);
+		finiteNumber(candidate.score, `checkpoint candidate '${candidate.entrantId}' score`, 0);
+		if (typeof candidate.pending !== "boolean") throw new TypeError("checkpoint candidate pending must be boolean.");
+	}
+	const seats = checkpoint.ranking === null ? candidates.length : checkpoint.ranking.kind === "top-k" ? Math.min(candidates.length, checkpoint.ranking.count) : Math.ceil(candidates.length * checkpoint.ranking.percent / 100);
+	return candidates.map((candidate) => {
+		const thresholdPassed = (checkpoint.threshold.minimumSolved === null || candidate.solved >= checkpoint.threshold.minimumSolved) && (checkpoint.threshold.minimumScore === null || candidate.score >= checkpoint.threshold.minimumScore);
+		const rankingPassed = checkpoint.ranking === null || standingByEntrant.get(candidate.entrantId).rank <= seats;
+		const provisional = checkpoint.settlement === "provisional" && candidate.pending;
+		return {
+			entrantId: candidate.entrantId,
+			advances: provisional || thresholdPassed && rankingPassed,
+			provisional
+		};
+	});
+}
+Object.freeze({
+	project: projectContestRules,
+	admission: decideContestAdmission,
+	rank: rankContestResults,
+	checkpoint: evaluateContestCheckpoint
+});
+//#endregion
+//#region src/core/resources.ts
+var MAX_LOGICAL_TIME_LIMIT_MS = Math.floor(Number.MAX_SAFE_INTEGER / 1e6);
+Object.freeze({
+	instructionBudget: 1e10,
+	logicalTimeLimitMs: 6e4,
+	memoryLimitBytes: 268435456,
+	outputLimitBytes: 4194304,
+	filesystemWriteLimitBytes: 67108864,
+	filesystemEntryLimit: 4096,
+	wallTimeLimitMs: 6e4
+});
+//#endregion
+//#region src/judge/problem-model.ts
+var PROBLEM_LOCALES = ["zh-TW", "en"];
+//#endregion
+//#region src/judge/problem-catalog-loader.ts
+var BROWSER_PROBLEM_SCHEMA$2 = "wasm-oj-browser-problem-v4";
+var PROBLEM_STARTER_LIMITS = Object.freeze({
+	filesPerLanguage: 128,
+	bytesPerFile: 262144,
+	totalBytesPerLanguage: 1048576
+});
+Object.freeze({
+	provider: "github",
+	owner: "wasm-oj",
+	repository: "problems",
+	ref: "main",
+	indexPath: "collection/index.json"
+});
+var LANGUAGES = [
+	"c",
+	"cpp",
+	"rust",
+	"go",
+	"python",
+	"javascript",
+	"typescript"
+];
+var POLICY_IDS = [
+	"baseline",
+	"efficient",
+	"optimal"
+];
+var CALIBRATION_METHOD = "wasm-oj-v2/compiled-average-optimal-rounded/v1";
+var ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var UTF8_ENCODER = new TextEncoder();
+var ProblemCollectionError = class extends Error {
+	kind;
+	constructor(message, kind, options) {
+		super(message, options);
+		this.kind = kind;
+		this.name = "ProblemCollectionError";
+	}
+};
+function parseStandaloneProblemBundle$2(value) {
+	if (!isRecord(value) || !hasExactKeys(value, ["schema", "problem"]) || value.schema !== "wasm-oj-browser-problem-v4") throw schemaError("The problem bundle uses an unsupported schema.");
+	return parseJudgeProblem(value.problem);
+}
+function parseJudgeProblem(value) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"id",
+		"number",
+		"title",
+		"trackId",
+		"track",
+		"difficulty",
+		"tags",
+		"statement",
+		"editorial",
+		"starterTemplates",
+		"judgeCases",
+		"scoring",
+		"complexities"
+	])) throw schemaError("The judge problem has an invalid shape.");
+	if (typeof value.id !== "string" || !ID_PATTERN.test(value.id) || !Number.isSafeInteger(value.number) || value.number < 1) throw schemaError("The judge problem has an invalid identity.");
+	const id = value.id;
+	const title = parseLocalizedText(value.title, `problem '${id}' title`);
+	if (typeof value.trackId !== "string" || !ID_PATTERN.test(value.trackId)) throw schemaError(`Problem '${id}' has an invalid track ID.`);
+	const track = parseLocalizedText(value.track, `problem '${id}' track`);
+	const statement = parseLocalizedText(value.statement, `problem '${id}' statement`, false);
+	const editorial = parseLocalizedText(value.editorial, `problem '${id}' editorial`, false);
+	const starterTemplates = parseStarterTemplates(value.starterTemplates, id);
+	const difficulty = parseDifficulty(value.difficulty, `problem '${id}'`);
+	const tags = parseTags(value.tags, `problem '${id}'`);
+	if (!Array.isArray(value.judgeCases) || value.judgeCases.length < 1 || value.judgeCases.length > 1e4) throw schemaError(`Problem '${value.id}' has an invalid case inventory.`);
+	const caseIds = /* @__PURE__ */ new Set();
+	const judgeCases = value.judgeCases.map((testCase, index) => {
+		if (!isRecord(testCase) || !hasExactKeys(testCase, [
+			"id",
+			"kind",
+			"input",
+			"output"
+		]) || typeof testCase.id !== "string" || !ID_PATTERN.test(testCase.id) || caseIds.has(testCase.id) || ![
+			"sample",
+			"adversarial",
+			"regression"
+		].includes(String(testCase.kind)) || typeof testCase.input !== "string" || typeof testCase.output !== "string") throw schemaError(`Problem '${value.id}' has an invalid case at position ${index + 1}.`);
+		caseIds.add(testCase.id);
+		return {
+			id: testCase.id,
+			kind: testCase.kind,
+			input: testCase.input,
+			output: testCase.output
+		};
+	});
+	if (judgeCases.filter((testCase) => testCase.kind === "sample").length !== 3) throw schemaError(`Problem '${value.id}' must contain exactly three sample cases.`);
+	const scoring = parseScoring(value.scoring, id);
+	if (!Array.isArray(value.complexities) || value.complexities.length < 2 || value.complexities.length > 32) throw schemaError(`Problem '${value.id}' has an invalid complexity inventory.`);
+	const complexities = value.complexities.map((complexity, index) => parseComplexity(complexity, id, index));
+	if (!complexities.at(-1)?.accepted) throw schemaError(`Problem '${id}' must end with its accepted complexity.`);
+	return {
+		id,
+		number: value.number,
+		title,
+		trackId: value.trackId,
+		track,
+		difficulty,
+		tags,
+		statement,
+		editorial,
+		starterTemplates,
+		judgeCases,
+		scoring,
+		complexities
+	};
+}
+function parseStarterTemplates(value, problemId) {
+	if (!isRecord(value) || !hasExactKeys(value, LANGUAGES)) throw schemaError(`Problem '${problemId}' must provide starter templates for every built-in language.`);
+	return Object.fromEntries(LANGUAGES.map((language) => [language, parseStarterTemplate(value[language], problemId, language)]));
+}
+function parseStarterTemplate(value, problemId, language) {
+	if (!isRecord(value) || !hasExactKeys(value, ["entry", "files"]) || !isRecord(value.files)) throw schemaError(`Problem '${problemId}' has an invalid '${language}' starter template.`);
+	const entry = parseStarterPath(value.entry, `problem '${problemId}' '${language}' starter entry`);
+	const paths = Object.keys(value.files).sort();
+	if (paths.length < 1 || paths.length > PROBLEM_STARTER_LIMITS.filesPerLanguage) throw schemaError(`Problem '${problemId}' '${language}' starter must contain between 1 and ${PROBLEM_STARTER_LIMITS.filesPerLanguage} files.`);
+	let totalBytes = 0;
+	const entries = [];
+	for (const rawPath of paths) {
+		const path = parseStarterPath(rawPath, `problem '${problemId}' '${language}' starter file`);
+		const content = value.files[rawPath];
+		if (typeof content !== "string" || hasUnpairedSurrogate(content)) throw schemaError(`Problem '${problemId}' '${language}' starter file '${path}' is not valid Unicode source text.`);
+		const bytes = UTF8_ENCODER.encode(content).byteLength;
+		if (bytes > PROBLEM_STARTER_LIMITS.bytesPerFile) throw schemaError(`Problem '${problemId}' '${language}' starter file '${path}' exceeds ${PROBLEM_STARTER_LIMITS.bytesPerFile} UTF-8 bytes.`);
+		totalBytes += bytes;
+		if (totalBytes > PROBLEM_STARTER_LIMITS.totalBytesPerLanguage) throw schemaError(`Problem '${problemId}' '${language}' starter files exceed ${PROBLEM_STARTER_LIMITS.totalBytesPerLanguage} UTF-8 bytes in total.`);
+		entries.push([path, content]);
+	}
+	const files = Object.fromEntries(entries);
+	if (!Object.hasOwn(files, entry) || UTF8_ENCODER.encode(files[entry]).byteLength === 0) throw schemaError(`Problem '${problemId}' '${language}' starter entry must name a non-empty file in its file map.`);
+	return {
+		entry,
+		files
+	};
+}
+function parseStarterPath(value, label) {
+	if (typeof value !== "string" || !value || value !== value.trim() || value.length > 4096 || value.startsWith("/") || value.endsWith("/") || value.includes("\\") || value.includes("\0") || value.split("/").some((segment) => !segment || segment === "." || segment === "..")) throw schemaError(`The ${label} is not a normalized relative path.`);
+	return value;
+}
+function hasUnpairedSurrogate(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const unit = value.charCodeAt(index);
+		if (unit >= 55296 && unit <= 56319) {
+			const next = value.charCodeAt(index + 1);
+			if (!(next >= 56320 && next <= 57343)) return true;
+			index += 1;
+		} else if (unit >= 56320 && unit <= 57343) return true;
+	}
+	return false;
+}
+function parseScoring(value, problemId) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"maximumPoints",
+		"calibration",
+		"policies",
+		"safetyLimits"
+	]) || value.maximumPoints !== 100) throw schemaError(`Problem '${problemId}' has invalid scoring metadata.`);
+	const calibration = value.calibration;
+	if (!isRecord(calibration) || !hasExactKeys(calibration, ["method", "profiles"]) || calibration.method !== CALIBRATION_METHOD) throw schemaError(`Problem '${problemId}' has invalid calibration metadata.`);
+	const profiles = calibration.profiles;
+	if (!isRecord(profiles) || !hasExactKeys(profiles, LANGUAGES) || LANGUAGES.some((language) => typeof profiles[language] !== "string" || !profiles[language] || profiles[language] !== profiles[language].trim())) throw schemaError(`Problem '${problemId}' has invalid calibration profiles.`);
+	if (!Array.isArray(value.policies) || value.policies.length !== POLICY_IDS.length) throw schemaError(`Problem '${problemId}' has invalid scoring policies.`);
+	const policies = value.policies.map((policy, index) => parsePolicy(policy, problemId, POLICY_IDS[index]));
+	if (policies.reduce((total, policy) => total + policy.points, 0) !== 100) throw schemaError(`Problem '${problemId}' policy points must sum to 100.`);
+	for (let index = 1; index < policies.length; index += 1) {
+		const broad = policies[index - 1].limits;
+		const strict = policies[index].limits;
+		const logicalInvalid = broad.logicalTimeLimitMs !== void 0 && (strict.logicalTimeLimitMs === void 0 || strict.logicalTimeLimitMs > broad.logicalTimeLimitMs);
+		const anyStricter = strict.instructionBudget < broad.instructionBudget || strict.memoryLimitBytes < broad.memoryLimitBytes || broad.logicalTimeLimitMs === void 0 && strict.logicalTimeLimitMs !== void 0 || broad.logicalTimeLimitMs !== void 0 && strict.logicalTimeLimitMs !== void 0 && strict.logicalTimeLimitMs < broad.logicalTimeLimitMs;
+		if (strict.instructionBudget > broad.instructionBudget || strict.memoryLimitBytes > broad.memoryLimitBytes || logicalInvalid || !anyStricter) throw schemaError(`Problem '${problemId}' policies are not broad-to-strict.`);
+	}
+	if (!isRecord(value.safetyLimits) || !hasExactKeys(value.safetyLimits, ["wallTimeLimitMs"]) || !isPositiveSafeInteger(value.safetyLimits.wallTimeLimitMs) || value.safetyLimits.wallTimeLimitMs > 6e5) throw schemaError(`Problem '${problemId}' has invalid safety limits.`);
+	return {
+		maximumPoints: 100,
+		calibration: {
+			method: CALIBRATION_METHOD,
+			profiles
+		},
+		policies,
+		safetyLimits: { wallTimeLimitMs: value.safetyLimits.wallTimeLimitMs }
+	};
+}
+function parsePolicy(value, problemId, expectedId) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"id",
+		"title",
+		"points",
+		"limits"
+	]) || value.id !== expectedId || !isPositiveSafeInteger(value.points) || !isRecord(value.limits)) throw schemaError(`Problem '${problemId}' has an invalid '${expectedId}' policy.`);
+	const keys = Object.keys(value.limits).sort();
+	if (JSON.stringify(keys) !== JSON.stringify(keys.includes("logicalTimeLimitMs") ? [
+		"instructionBudget",
+		"logicalTimeLimitMs",
+		"memoryLimitBytes"
+	] : ["instructionBudget", "memoryLimitBytes"])) throw schemaError(`Problem '${problemId}' policy '${expectedId}' has invalid limits.`);
+	if (!isPositiveSafeInteger(value.limits.instructionBudget) || !isPositiveSafeInteger(value.limits.memoryLimitBytes) || value.limits.memoryLimitBytes < 65536 || value.limits.memoryLimitBytes > 4294967296 || value.limits.memoryLimitBytes % 65536 !== 0 || value.limits.logicalTimeLimitMs !== void 0 && (!isPositiveSafeInteger(value.limits.logicalTimeLimitMs) || value.limits.logicalTimeLimitMs > MAX_LOGICAL_TIME_LIMIT_MS)) throw schemaError(`Problem '${problemId}' policy '${expectedId}' has invalid resource values.`);
+	const limits = {
+		instructionBudget: value.limits.instructionBudget,
+		memoryLimitBytes: value.limits.memoryLimitBytes,
+		...value.limits.logicalTimeLimitMs === void 0 ? {} : { logicalTimeLimitMs: value.limits.logicalTimeLimitMs }
+	};
+	return {
+		id: expectedId,
+		title: parseLocalizedText(value.title, `problem '${problemId}' policy '${expectedId}' title`),
+		points: value.points,
+		limits
+	};
+}
+function parseComplexity(value, problemId, index) {
+	if (!isRecord(value) || !hasExactKeys(value, [
+		"name",
+		"time",
+		"space",
+		"accepted"
+	]) || typeof value.time !== "string" || !value.time || typeof value.space !== "string" || !value.space || typeof value.accepted !== "boolean") throw schemaError(`Problem '${problemId}' has an invalid complexity at position ${index + 1}.`);
+	return {
+		name: parseLocalizedText(value.name, `problem '${problemId}' complexity name`),
+		time: value.time,
+		space: value.space,
+		accepted: value.accepted
+	};
+}
+function parseLocalizedText(value, label, trimmed = true) {
+	if (!isRecord(value) || !hasExactKeys(value, PROBLEM_LOCALES)) throw schemaError(`${label} is invalid.`);
+	for (const locale of PROBLEM_LOCALES) if (typeof value[locale] !== "string" || !value[locale] || trimmed && value[locale] !== value[locale].trim()) throw schemaError(`${label}[${locale}] is invalid.`);
+	return value;
+}
+function parseDifficulty(value, label) {
+	if (value !== "easy" && value !== "medium" && value !== "hard") throw schemaError(`${label} has an invalid difficulty.`);
+	return value;
+}
+function parseTags(value, label) {
+	if (!Array.isArray(value) || value.length < 1 || value.length > 32 || value.some((tag) => typeof tag !== "string" || !tag || tag !== tag.trim()) || new Set(value).size !== value.length) throw schemaError(`${label} has invalid tags.`);
+	return value;
+}
+function hasExactKeys(value, expected) {
+	const actual = Object.keys(value).sort();
+	const expectedKeys = [...expected].sort();
+	return actual.length === expectedKeys.length && actual.every((key, index) => key === expectedKeys[index]);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPositiveSafeInteger(value) {
+	return Number.isSafeInteger(value) && value > 0;
+}
+function schemaError(message) {
+	return new ProblemCollectionError(message, "schema");
+}
+//#endregion
+//#region src/online-judge/public-projection.ts
+/** Parses the redacted contest object. Its repository descriptor supplies the content identity. */
+function parseContestPublicProblemProjection(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Contest-public projection must be an object.");
+	const record = value;
+	if (Object.keys(record).sort().join("\0") !== "problem\0schema" || record.schema !== "wasm-oj-platform/contest-public-problem-projection/v1") throw new TypeError("Contest-public projection has an invalid shape or schema.");
+	if (!record.problem || typeof record.problem !== "object" || Array.isArray(record.problem)) throw new TypeError("Contest-public projection contains an invalid problem.");
+	const rawProblem = record.problem;
+	const editorial = rawProblem.editorial;
+	if (!editorial || typeof editorial !== "object" || Array.isArray(editorial) || Object.keys(editorial).sort().join("\0") !== "en\0zh-TW" || editorial["zh-TW"] !== "" || editorial.en !== "") throw new TypeError("Contest-public projection contains non-public problem data.");
+	const parsed = parseStandaloneProblemBundle$2({
+		schema: BROWSER_PROBLEM_SCHEMA$2,
+		problem: {
+			...rawProblem,
+			editorial: {
+				"zh-TW": "redacted",
+				en: "redacted"
+			}
+		}
+	});
+	if (parsed.judgeCases.some((testCase) => testCase.kind !== "sample")) throw new TypeError("Contest-public projection contains non-public problem data.");
+	return {
+		schema: CONTEST_PUBLIC_PROJECTION_SCHEMA,
+		problem: {
+			...parsed,
+			editorial: {
+				"zh-TW": "",
+				en: ""
+			}
+		}
+	};
+}
+//#endregion
+//#region src/online-judge/compile-profiles.ts
+function record$3(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
+	return value;
+}
+function parseJudgeAllowedProfiles(value, label = "allowedProfiles") {
+	const profiles = record$3(value, label);
+	const entries = Object.entries(profiles).sort(([left], [right]) => left.localeCompare(right));
+	if (entries.length < 1) throw new TypeError(`${label} must contain at least one compile profile.`);
+	const result = {};
+	for (const [language, candidate] of entries) {
+		if (!isBuiltinLanguage(language)) throw new TypeError(`${label} language '${language}' is unsupported.`);
+		const profile = record$3(candidate, `${label}.${language}`);
+		if (JSON.stringify(Object.keys(profile).sort()) !== JSON.stringify(["optimization", "target"])) throw new TypeError(`${label}.${language} has an invalid shape.`);
+		if (profile.target !== "wasip1" && profile.target !== "wasix") throw new TypeError(`${label}.${language}.target is unsupported.`);
+		if (profile.optimization !== "debug" && profile.optimization !== "release") throw new TypeError(`${label}.${language}.optimization is unsupported.`);
+		result[language] = {
+			target: profile.target,
+			optimization: profile.optimization
+		};
+	}
+	return result;
+}
+//#endregion
+//#region src/online-judge/trusted-judge-wasm.ts
+var TRUSTED_JUDGE_WASM_MAX_BYTES = 8388608;
+var I32 = 127;
+var I64 = 126;
+var errno = (parameters) => ({
+	parameters,
+	results: [I32]
+});
+Object.freeze({
+	args_get: errno([I32, I32]),
+	args_sizes_get: errno([I32, I32]),
+	clock_res_get: errno([I32, I32]),
+	clock_time_get: errno([
+		I32,
+		I64,
+		I32
+	]),
+	environ_get: errno([I32, I32]),
+	environ_sizes_get: errno([I32, I32]),
+	fd_advise: errno([
+		I32,
+		I64,
+		I64,
+		I32
+	]),
+	fd_allocate: errno([
+		I32,
+		I64,
+		I64
+	]),
+	fd_close: errno([I32]),
+	fd_datasync: errno([I32]),
+	fd_fdstat_get: errno([I32, I32]),
+	fd_fdstat_set_flags: errno([I32, I32]),
+	fd_fdstat_set_rights: errno([
+		I32,
+		I64,
+		I64
+	]),
+	fd_filestat_get: errno([I32, I32]),
+	fd_filestat_set_size: errno([I32, I64]),
+	fd_filestat_set_times: errno([
+		I32,
+		I64,
+		I64,
+		I32
+	]),
+	fd_pread: errno([
+		I32,
+		I32,
+		I32,
+		I64,
+		I32
+	]),
+	fd_prestat_dir_name: errno([
+		I32,
+		I32,
+		I32
+	]),
+	fd_prestat_get: errno([I32, I32]),
+	fd_pwrite: errno([
+		I32,
+		I32,
+		I32,
+		I64,
+		I32
+	]),
+	fd_read: errno([
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	fd_readdir: errno([
+		I32,
+		I32,
+		I32,
+		I64,
+		I32
+	]),
+	fd_renumber: errno([I32, I32]),
+	fd_seek: errno([
+		I32,
+		I64,
+		I32,
+		I32
+	]),
+	fd_sync: errno([I32]),
+	fd_tell: errno([I32, I32]),
+	fd_write: errno([
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	path_create_directory: errno([
+		I32,
+		I32,
+		I32
+	]),
+	path_filestat_get: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	path_filestat_set_times: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I64,
+		I64,
+		I32
+	]),
+	path_link: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	path_open: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I32,
+		I64,
+		I64,
+		I32,
+		I32
+	]),
+	path_readlink: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	path_remove_directory: errno([
+		I32,
+		I32,
+		I32
+	]),
+	path_rename: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	path_symlink: errno([
+		I32,
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	path_unlink_file: errno([
+		I32,
+		I32,
+		I32
+	]),
+	poll_oneoff: errno([
+		I32,
+		I32,
+		I32,
+		I32
+	]),
+	proc_exit: {
+		parameters: [I32],
+		results: []
+	},
+	proc_raise: errno([I32]),
+	random_get: errno([I32, I32]),
+	sched_yield: errno([])
+});
+Object.freeze(/* @__PURE__ */ new Set([
+	"args_get",
+	"args_sizes_get",
+	"clock_res_get",
+	"clock_time_get",
+	"environ_get",
+	"environ_sizes_get",
+	"fd_advise",
+	"fd_allocate",
+	"fd_close",
+	"fd_datasync",
+	"fd_fdstat_get",
+	"fd_fdstat_set_flags",
+	"fd_fdstat_set_rights",
+	"fd_filestat_get",
+	"fd_filestat_set_size",
+	"fd_filestat_set_times",
+	"fd_pread",
+	"fd_prestat_dir_name",
+	"fd_prestat_get",
+	"fd_pwrite",
+	"fd_read",
+	"fd_readdir",
+	"fd_renumber",
+	"fd_seek",
+	"fd_sync",
+	"fd_tell",
+	"fd_write",
+	"path_create_directory",
+	"path_filestat_get",
+	"path_filestat_set_times",
+	"path_link",
+	"path_open",
+	"path_readlink",
+	"path_remove_directory",
+	"path_rename",
+	"path_symlink",
+	"path_unlink_file",
+	"poll_oneoff",
+	"proc_exit",
+	"proc_raise",
+	"random_get",
+	"sched_yield"
+]));
+var TRUSTED_JUDGE_RUNTIME_PROFILES = Object.freeze(/* @__PURE__ */ new Set([
+	"c-wasip1-release",
+	"cpp-wasip1-release",
+	"rust-wasip1-release",
+	"go-wasip1-release"
+]));
+//#endregion
+//#region src/online-judge/repository-authoring.ts
+var REPOSITORY_AUTHORING_JUDGES_SCHEMA = "wasm-oj-platform/repository-authoring-judges/v1";
+var SHA256$1 = /^[0-9a-f]{64}$/;
+var SLUG$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PATH$1 = /^(?!\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*\\)(?!.*\/$)[^\u0000]+$/;
+var GUEST_PATH = /^\/(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*\\)(?!.*\/$)[^\u0000]+$/;
+var MAX_ASSET_BYTES = 4194304;
+var MAX_ASSET_TOTAL_BYTES = 4194304;
+function record$2(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
+	return value;
+}
+function exact$2(value, keys, label) {
+	if (Object.keys(value).sort().join("\0") !== [...keys].sort().join("\0")) throw new TypeError(`${label} has an invalid shape.`);
+}
+function sourceObject(value, label, maximum) {
+	const object = record$2(value, label);
+	exact$2(object, [
+		"bytes",
+		"path",
+		"sha256"
+	], label);
+	if (typeof object.path !== "string" || object.path.length < 1 || object.path.length > 512 || !PATH$1.test(object.path)) throw new TypeError(`${label}.path must be a normalized repository-relative POSIX path.`);
+	if (!Number.isSafeInteger(object.bytes) || object.bytes < 1 || object.bytes > maximum) throw new TypeError(`${label}.bytes is outside its limit.`);
+	if (typeof object.sha256 !== "string" || !SHA256$1.test(object.sha256)) throw new TypeError(`${label}.sha256 is invalid.`);
+	return {
+		path: object.path,
+		bytes: object.bytes,
+		sha256: object.sha256
+	};
+}
+function judge(value, slug) {
+	const input = record$2(value, `repository authoring '${slug}' judge`);
+	if (input.kind === "text") {
+		exact$2(input, ["kind"], `repository authoring '${slug}' text judge`);
+		return { kind: "text" };
+	}
+	if (input.kind !== "checker" && input.kind !== "interactive") throw new TypeError(`Repository authoring '${slug}' judge kind is unsupported.`);
+	exact$2(input, input.kind === "checker" ? [
+		"args",
+		"artifact",
+		"assets",
+		"kind"
+	] : [
+		"args",
+		"artifact",
+		"assets",
+		"inputPath",
+		"kind"
+	], `repository authoring '${slug}' ${input.kind}`);
+	const artifactValue = record$2(input.artifact, `repository authoring '${slug}' ${input.kind} artifact`);
+	exact$2(artifactValue, [
+		"bytes",
+		"path",
+		"runtimeProfile",
+		"sha256"
+	], `repository authoring '${slug}' ${input.kind} artifact`);
+	if (typeof artifactValue.runtimeProfile !== "string" || !TRUSTED_JUDGE_RUNTIME_PROFILES.has(artifactValue.runtimeProfile)) throw new TypeError(`Repository authoring '${slug}' ${input.kind} runtimeProfile is unsupported.`);
+	const artifact = {
+		...sourceObject({
+			bytes: artifactValue.bytes,
+			path: artifactValue.path,
+			sha256: artifactValue.sha256
+		}, `repository authoring '${slug}' ${input.kind} artifact`, TRUSTED_JUDGE_WASM_MAX_BYTES),
+		runtimeProfile: artifactValue.runtimeProfile
+	};
+	if (!artifact.path.endsWith(".wasm")) throw new TypeError(`Repository authoring '${slug}' ${input.kind} artifact path must end in '.wasm'.`);
+	if (!Array.isArray(input.assets) || input.assets.length > 256) throw new TypeError(`Repository authoring '${slug}' ${input.kind} assets are invalid.`);
+	const namespace = input.kind === "checker" ? "/checker/assets/" : "/interactor/assets/";
+	const assets = input.assets.map((candidate, index) => {
+		const asset = record$2(candidate, `repository authoring '${slug}' ${input.kind} asset ${index}`);
+		exact$2(asset, [
+			"bytes",
+			"guestPath",
+			"path",
+			"sha256"
+		], `repository authoring '${slug}' ${input.kind} asset ${index}`);
+		if (typeof asset.guestPath !== "string" || !GUEST_PATH.test(asset.guestPath) || !asset.guestPath.startsWith(namespace)) throw new TypeError(`Repository authoring '${slug}' ${input.kind} asset ${index} guestPath must be inside '${namespace}'.`);
+		return {
+			...sourceObject({
+				bytes: asset.bytes,
+				path: asset.path,
+				sha256: asset.sha256
+			}, `repository authoring '${slug}' ${input.kind} asset ${index}`, MAX_ASSET_BYTES),
+			guestPath: asset.guestPath
+		};
+	});
+	const guestPaths = assets.map((asset) => asset.guestPath);
+	const repositoryPaths = [artifact.path, ...assets.map((asset) => asset.path)];
+	if (new Set(guestPaths).size !== guestPaths.length || new Set(repositoryPaths).size !== repositoryPaths.length) throw new TypeError(`Repository authoring '${slug}' ${input.kind} repeats an asset or repository path.`);
+	if (assets.reduce((total, asset) => total + asset.bytes, 0) > MAX_ASSET_TOTAL_BYTES) throw new TypeError(`Repository authoring '${slug}' ${input.kind} assets exceed 4 MiB.`);
+	if (!Array.isArray(input.args) || input.args.length > 64 || input.args.some((argument) => typeof argument !== "string" || argument.includes("\0") || new TextEncoder().encode(argument).byteLength > 4096)) throw new TypeError(`Repository authoring '${slug}' ${input.kind} args are invalid.`);
+	const args = [...input.args];
+	if (input.kind === "checker") return {
+		kind: "checker",
+		artifact,
+		assets,
+		args
+	};
+	if (typeof input.inputPath !== "string" || !GUEST_PATH.test(input.inputPath) || !input.inputPath.startsWith("/interactor/input/")) throw new TypeError(`Repository authoring '${slug}' interactive inputPath must be inside '/interactor/input/'.`);
+	return {
+		kind: "interactive",
+		artifact,
+		assets,
+		args,
+		inputPath: input.inputPath
+	};
+}
+/** Author-only input used by collection build; never accepted by the platform sync boundary. */
+function parseRepositoryAuthoringJudges(value) {
+	const source = record$2(value, "repository authoring judges");
+	exact$2(source, ["problems", "schema"], "repository authoring judges");
+	if (source.schema !== "wasm-oj-platform/repository-authoring-judges/v1") throw new TypeError(`Repository authoring judge schema must be '${REPOSITORY_AUTHORING_JUDGES_SCHEMA}'.`);
+	if (!Array.isArray(source.problems) || source.problems.length < 1 || source.problems.length > 1e3) throw new TypeError("Repository authoring judges must contain between 1 and 1000 problems.");
+	const slugs = /* @__PURE__ */ new Set();
+	return {
+		schema: REPOSITORY_AUTHORING_JUDGES_SCHEMA,
+		problems: source.problems.map((candidate, index) => {
+			const problem = record$2(candidate, `repository authoring judge problem ${index + 1}`);
+			exact$2(problem, [
+				"allowedProfiles",
+				"judge",
+				"slug"
+			], `repository authoring judge problem ${index + 1}`);
+			if (typeof problem.slug !== "string" || !SLUG$1.test(problem.slug) || slugs.has(problem.slug)) throw new TypeError(`Repository authoring judge problem ${index + 1} has an invalid or duplicate slug.`);
+			slugs.add(problem.slug);
+			return {
+				slug: problem.slug,
+				allowedProfiles: parseJudgeAllowedProfiles(problem.allowedProfiles, `repository authoring '${problem.slug}' allowedProfiles`),
+				judge: judge(problem.judge, problem.slug)
+			};
+		})
+	};
+}
+//#endregion
+//#region src/online-judge/repository-contract.ts
+var REPOSITORY_SCHEMA = "wasm-oj-platform/repository/v1";
+var PROBLEMS_SCHEMA = "wasm-oj-platform/problems/v1";
+var CONTESTS_SCHEMA = "wasm-oj-platform/contests/v2";
+var MAX_PUBLIC_BUNDLE_BYTES = 8388608;
+var MAX_JUDGE_PACKAGE_BYTES = 33554432;
+var SHA256 = /^[0-9a-f]{64}$/;
+var SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PATH = /^(?!\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*\\)(?!.*\/$)[^\u0000-\u001f\u007f]+$/;
+var decoder = new TextDecoder("utf-8", { fatal: true });
+function record$1(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
+	return value;
+}
+function exact$1(value, keys, label) {
+	const actual = Object.keys(value).sort();
+	const expected = [...keys].sort();
+	if (actual.join("\0") !== expected.join("\0")) throw new TypeError(`${label} has an invalid shape.`);
+}
+function repositoryPath(value, label) {
+	if (typeof value !== "string" || value.length < 1 || value.length > 512 || !PATH.test(value)) throw new TypeError(`${label} must be a normalized repository-relative POSIX path.`);
+	return value;
+}
+function slug(value, label) {
+	if (typeof value !== "string" || value.length > 128 || !SLUG.test(value)) throw new TypeError(`${label} is invalid.`);
+	return value;
+}
+function boundedText(value, label, maximumBytes) {
+	if (typeof value !== "string" || new TextEncoder().encode(value).byteLength > maximumBytes) throw new TypeError(`${label} exceeds its UTF-8 byte limit.`);
+	return value;
+}
+function localizedText(value, label, maximumBytes) {
+	const input = record$1(value, label);
+	exact$1(input, ["en", "zh-TW"], label);
+	return {
+		"zh-TW": boundedText(input["zh-TW"], `${label}.zh-TW`, maximumBytes),
+		en: boundedText(input.en, `${label}.en`, maximumBytes)
+	};
+}
+function descriptor(value, label, maximumBytes) {
+	const input = record$1(value, label);
+	exact$1(input, [
+		"bytes",
+		"path",
+		"sha256"
+	], label);
+	if (!Number.isSafeInteger(input.bytes) || input.bytes < 1 || input.bytes > maximumBytes) throw new TypeError(`${label}.bytes is outside its limit.`);
+	if (typeof input.sha256 !== "string" || !SHA256.test(input.sha256)) throw new TypeError(`${label}.sha256 must be a lowercase SHA-256 digest.`);
+	return {
+		path: repositoryPath(input.path, `${label}.path`),
+		bytes: input.bytes,
+		sha256: input.sha256
+	};
+}
+function parseJsonBytes(bytes, label) {
+	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 2 || bytes.byteLength > 2097152) throw new TypeError(`${label} bytes are outside the 2 MiB limit.`);
+	let text;
+	try {
+		text = decoder.decode(bytes);
+	} catch (error) {
+		throw new TypeError(`${label} must be valid UTF-8.`, { cause: error });
+	}
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new TypeError(`${label} must be valid JSON.`, { cause: error });
+	}
+}
+function parseRepositoryRootValue(value) {
+	const input = record$1(value, "repository manifest");
+	exact$1(input, [
+		"contests",
+		"problems",
+		"schema"
+	], "repository manifest");
+	if (input.schema !== "wasm-oj-platform/repository/v1") throw new TypeError(`Repository schema must be '${REPOSITORY_SCHEMA}'.`);
+	const problems = repositoryPath(input.problems, "repository manifest problems");
+	const contests = repositoryPath(input.contests, "repository manifest contests");
+	if (problems === contests || problems === "wasm-oj.json" || contests === "wasm-oj.json") throw new TypeError("Repository manifest paths must be distinct from each other and the root manifest.");
+	return {
+		schema: REPOSITORY_SCHEMA,
+		problems,
+		contests
+	};
+}
+function parseRepositoryRoot(bytes) {
+	return parseRepositoryRootValue(parseJsonBytes(bytes, "repository manifest"));
+}
+function parseRepositoryProblemsValue(value) {
+	const input = record$1(value, "problems manifest");
+	exact$1(input, ["problems", "schema"], "problems manifest");
+	if (input.schema !== "wasm-oj-platform/problems/v1") throw new TypeError(`Problems schema must be '${PROBLEMS_SCHEMA}'.`);
+	if (!Array.isArray(input.problems) || input.problems.length < 1 || input.problems.length > 1e3) throw new TypeError("Problems manifest must contain between 1 and 1000 problems.");
+	const slugs = /* @__PURE__ */ new Set();
+	const orders = /* @__PURE__ */ new Set();
+	const paths = /* @__PURE__ */ new Set();
+	const problems = input.problems.map((candidate, index) => {
+		const problem = record$1(candidate, `problem ${index + 1}`);
+		exact$1(problem, [
+			"contestBundle",
+			"judgePackage",
+			"order",
+			"practiceBundle",
+			"practiceEnabled",
+			"slug",
+			"summary",
+			"title"
+		], `problem ${index + 1}`);
+		const problemSlug = slug(problem.slug, `problem ${index + 1}.slug`);
+		if (slugs.has(problemSlug)) throw new TypeError(`Problem slug '${problemSlug}' is duplicated.`);
+		if (!Number.isSafeInteger(problem.order) || problem.order < 1 || problem.order > 1e3 || orders.has(problem.order)) throw new TypeError(`Problem '${problemSlug}' order is invalid or duplicated.`);
+		if (typeof problem.practiceEnabled !== "boolean") throw new TypeError(`Problem '${problemSlug}' practiceEnabled must be boolean.`);
+		const practiceBundle = descriptor(problem.practiceBundle, `problem '${problemSlug}' practiceBundle`, MAX_PUBLIC_BUNDLE_BYTES);
+		const contestBundle = descriptor(problem.contestBundle, `problem '${problemSlug}' contestBundle`, MAX_PUBLIC_BUNDLE_BYTES);
+		const judgePackage = descriptor(problem.judgePackage, `problem '${problemSlug}' judgePackage`, MAX_JUDGE_PACKAGE_BYTES);
+		for (const object of [
+			practiceBundle,
+			contestBundle,
+			judgePackage
+		]) {
+			if (paths.has(object.path)) throw new TypeError(`Repository object path '${object.path}' is declared more than once.`);
+			paths.add(object.path);
+		}
+		slugs.add(problemSlug);
+		orders.add(problem.order);
+		return {
+			slug: problemSlug,
+			order: problem.order,
+			title: localizedText(problem.title, `problem '${problemSlug}' title`, 4096),
+			summary: localizedText(problem.summary, `problem '${problemSlug}' summary`, 16384),
+			practiceEnabled: problem.practiceEnabled,
+			practiceBundle,
+			contestBundle,
+			judgePackage
+		};
+	});
+	problems.sort((left, right) => left.order - right.order);
+	return {
+		schema: PROBLEMS_SCHEMA,
+		problems
+	};
+}
+function parseRepositoryProblems(bytes) {
+	return parseRepositoryProblemsValue(parseJsonBytes(bytes, "problems manifest"));
+}
+function parseRepositoryContestsValue(value) {
+	const input = record$1(value, "contests manifest");
+	exact$1(input, ["contests", "schema"], "contests manifest");
+	if (input.schema !== "wasm-oj-platform/contests/v2") throw new TypeError(`Contests schema must be '${CONTESTS_SCHEMA}'.`);
+	if (!Array.isArray(input.contests) || input.contests.length > 1e3) throw new TypeError("Contests manifest may contain at most 1000 contests.");
+	const slugs = /* @__PURE__ */ new Set();
+	return {
+		schema: CONTESTS_SCHEMA,
+		contests: input.contests.map((candidate, index) => {
+			const contest = record$1(candidate, `contest ${index + 1}`);
+			exact$1(contest, [
+				"accessMode",
+				"description",
+				"rules",
+				"slug",
+				"status",
+				"title"
+			], `contest ${index + 1}`);
+			const contestSlug = slug(contest.slug, `contest ${index + 1}.slug`);
+			if (slugs.has(contestSlug)) throw new TypeError(`Contest slug '${contestSlug}' is duplicated.`);
+			if (contest.status !== "draft" && contest.status !== "published" && contest.status !== "archived") throw new TypeError(`Contest '${contestSlug}' status is invalid.`);
+			if (contest.accessMode !== "public" && contest.accessMode !== "invite") throw new TypeError(`Contest '${contestSlug}' accessMode is invalid.`);
+			const rules = parseContestRules(contest.rules, `contest '${contestSlug}' rules`);
+			slugs.add(contestSlug);
+			return {
+				slug: contestSlug,
+				status: contest.status,
+				title: boundedText(contest.title, `contest '${contestSlug}' title`, 4096),
+				description: boundedText(contest.description, `contest '${contestSlug}' description`, 65536),
+				accessMode: contest.accessMode,
+				rules
+			};
+		})
+	};
+}
+function parseRepositoryContests(bytes) {
+	return parseRepositoryContestsValue(parseJsonBytes(bytes, "contests manifest"));
+}
+function validateRepositoryCatalog(root, problems, contests) {
+	const problemSlugs = new Set(problems.problems.map((problem) => problem.slug));
+	for (const contest of contests.contests) for (const problem of contest.rules.problems) if (!problemSlugs.has(problem.slug)) throw new TypeError(`Contest '${contest.slug}' references unknown problem '${problem.slug}'.`);
+	return {
+		root,
+		problems,
+		contests
+	};
+}
+//#endregion
 //#region src/path-safety.ts
 /** Resolve only the operating system's own temporary-directory alias. */
 async function canonicalizeSystemTemporaryPrefix(value) {
@@ -31,516 +1941,338 @@ async function anchoredPathHasNoSymlink(value) {
 }
 //#endregion
 //#region src/collection-cli.ts
-var SOURCE_SCHEMA = "wasm-oj-browser-collection-source-v1";
-var DEFAULT_INDEX_PATH = "collection/index.json";
-var DEFAULT_SOURCE_PATH = "collection/source.json";
-var INDEX_MAX_BYTES = 524288;
-var COLLECTION_SOURCE_MAX_BYTES = 2097152;
-var STATEMENT_MAX_BYTES = 2097152;
-var PUBLIC_BUNDLE_MAX_BYTES = 8388608;
-var AUTHORING_BUNDLE_MAX_BYTES = 33554432;
-var MANAGED_MAX_BYTES = 2097152;
-var JUDGE_PACKAGE_MAX_BYTES = 33554432;
+var AUTHORING_SCHEMA = "wasm-oj-platform/repository-authoring/v1";
+var SOURCE_PATH = "collection/source.json";
+var ROOT_PATH = "wasm-oj.json";
+var PROBLEMS_PATH = "collection/problems.json";
+var CONTESTS_PATH = "collection/contests.json";
+var JSON_MAX_BYTES = 2097152;
+var PUBLIC_MAX_BYTES = 8388608;
+var PACKAGE_MAX_BYTES = 33554432;
 function fail(message) {
 	throw new Error(message);
 }
-function normalizedRelativePath(value, label) {
-	if (typeof value !== "string" || !value || value.startsWith("/") || value.includes("\\") || value.includes("\0") || value.endsWith("/")) return fail(`${label} must be a normalized relative POSIX path.`);
-	if (value.split("/").some((segment) => !segment || segment === "." || segment === "..")) return fail(`${label} must be a normalized relative POSIX path.`);
-	return value;
-}
-function portableOutputPath(value, label) {
-	const relative = normalizedRelativePath(value, label);
-	if (relative.split("/").some((segment) => !/^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(segment))) return fail(`${label} must use only portable ASCII path segments.`);
-	return relative;
-}
-function resolveInside(root, relativeValue, label) {
-	const relative = normalizedRelativePath(relativeValue, label);
-	return path.join(root, ...relative.split("/"));
-}
-function collisionKey(value) {
-	return value.normalize("NFC").toLocaleLowerCase("en-US");
-}
-async function assertRepositoryRoot(root) {
-	const anchoredRoot = await canonicalizeSystemTemporaryPrefix(path.resolve(root));
-	if (!await anchoredPathHasNoSymlink(anchoredRoot)) fail("repository root must not traverse a symbolic link.");
-	const metadata = await lstat(anchoredRoot);
-	if (metadata.isSymbolicLink() || !metadata.isDirectory()) fail("repository root must be a real directory.");
-}
-async function readBoundedRepositoryFile(options, relativeValue, label, maximumBytes, expectedBytes) {
-	const file = resolveInside(options.root, relativeValue, label);
-	if (!await anchoredPathHasNoSymlink(file)) fail(`${label} must not traverse a symbolic link.`);
-	let handle;
-	try {
-		handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
-	} catch (error) {
-		throw new Error(`${label} must be a readable regular file.`, { cause: error });
-	}
-	try {
-		const metadata = await handle.stat();
-		if (!metadata.isFile() || metadata.size > maximumBytes || expectedBytes !== void 0 && metadata.size !== expectedBytes) fail(`${label} is outside its allowed byte limit.`);
-		return new Uint8Array(await handle.readFile());
-	} finally {
-		await handle.close();
-	}
+function sameLocalizedText(left, right) {
+	return left["zh-TW"] === right["zh-TW"] && left.en === right.en;
 }
-async function assertOutputPathSafe(options, relativeValue, label) {
-	const output = resolveInside(options.root, relativeValue, label);
-	if (!await anchoredPathHasNoSymlink(output)) fail(`${label} must not traverse a symbolic link.`);
-	let metadata;
-	try {
-		metadata = await lstat(output);
-	} catch (error) {
-		if (error.code === "ENOENT") return;
-		throw error;
-	}
-	if (metadata.isSymbolicLink() || !metadata.isFile()) fail(`${label} must replace only a regular file.`);
+function normalizedPath(value, label) {
+	if (typeof value !== "string" || value.length < 1 || value.length > 512 || value.startsWith("/") || value.endsWith("/") || value.includes("\\") || value.includes("\0") || value.split("/").some((part) => !part || part === "." || part === "..")) fail(`${label} must be a normalized repository-relative POSIX path.`);
+	return value;
 }
-async function existingPathIdentity(options, relativeValue, label) {
-	const file = resolveInside(options.root, relativeValue, label);
-	if (!await anchoredPathHasNoSymlink(file)) fail(`${label} must not traverse a symbolic link.`);
-	try {
-		const metadata = await lstat(file, { bigint: true });
-		if (metadata.isSymbolicLink()) fail(`${label} must not be a symbolic link.`);
-		return `${metadata.dev}:${metadata.ino}`;
-	} catch (error) {
-		if (error.code === "ENOENT") return void 0;
-		throw error;
-	}
-}
-async function assertNoFilesystemAliases(options, inputs, outputs) {
-	const inputIdentities = /* @__PURE__ */ new Map();
-	for (const input of inputs) {
-		const identity = await existingPathIdentity(options, input, `declared input '${input}'`);
-		if (identity !== void 0 && !inputIdentities.has(identity)) inputIdentities.set(identity, input);
-	}
-	const outputIdentities = /* @__PURE__ */ new Map();
-	for (const output of outputs) {
-		const identity = await existingPathIdentity(options, output, `generated output '${output}'`);
-		if (identity === void 0) continue;
-		const input = inputIdentities.get(identity);
-		if (input !== void 0) fail(`generated output '${output}' aliases declared input '${input}' on this filesystem.`);
-		const priorOutput = outputIdentities.get(identity);
-		if (priorOutput !== void 0) fail(`generated outputs '${priorOutput}' and '${output}' alias on this filesystem.`);
-		outputIdentities.set(identity, output);
-	}
-}
-async function ensureOutputParent(options, relativeValue) {
-	const relativeParent = path.posix.dirname(normalizedRelativePath(relativeValue, "output path"));
-	if (relativeParent === ".") return;
-	let current = options.root;
-	for (const segment of relativeParent.split("/")) {
-		current = path.join(current, segment);
-		try {
-			const metadata = await lstat(current);
-			if (metadata.isSymbolicLink() || !metadata.isDirectory()) fail(`output directory '${relativeParent}' must contain only real directories.`);
-		} catch (error) {
-			if (error.code !== "ENOENT") throw error;
-			try {
-				await mkdir(current);
-			} catch (mkdirError) {
-				if (mkdirError.code !== "EEXIST") throw mkdirError;
-				const metadata = await lstat(current);
-				if (metadata.isSymbolicLink() || !metadata.isDirectory()) fail(`output directory '${relativeParent}' must contain only real directories.`);
-			}
-		}
-	}
+function record(value, label) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) fail(`${label} must be an object.`);
+	return value;
 }
-async function atomicRepositoryWrite(options, relativeValue, bytes) {
-	const output = resolveInside(options.root, relativeValue, "output path");
-	await ensureOutputParent(options, relativeValue);
-	const temporary = `${output}.${process.pid}.${crypto.randomUUID()}.tmp`;
-	try {
-		await writeFile(temporary, bytes, {
-			flag: "wx",
-			mode: 420
-		});
-		await rename(temporary, output);
-	} finally {
-		await rm(temporary, { force: true });
-	}
+function exact(value, keys, label) {
+	const actual = Object.keys(value).sort();
+	const expected = [...keys].sort();
+	if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) fail(`${label} has an invalid shape.`);
 }
 function parseOptions(arguments_) {
-	const [commandValue, ...rest] = arguments_;
-	if (commandValue !== "build" && commandValue !== "verify") return fail("Usage: woj organizer collection <build|verify> [repository-root] [--index path] [--source path] [--managed path] [--managed-source path]");
+	const [command, ...rest] = arguments_;
+	if (command !== "build" && command !== "verify") fail("Usage: woj organizer collection <build|verify> [repository-root] [--source path]");
 	let root = ".";
-	let indexPath = DEFAULT_INDEX_PATH;
-	let sourcePath = DEFAULT_SOURCE_PATH;
-	let managedPath;
-	let managedSourcePath;
-	let sawRoot = false;
+	let sourcePath = SOURCE_PATH;
+	let rootSeen = false;
 	for (let index = 0; index < rest.length; index += 1) {
 		const argument = rest[index];
-		if (argument === "--index" || argument === "--source" || argument === "--managed" || argument === "--managed-source") {
+		if (argument === "--source") {
 			const value = rest[index + 1];
-			if (!value) return fail(`${argument} requires a path.`);
-			if (argument === "--index") indexPath = portableOutputPath(value, "index path");
-			else if (argument === "--source") sourcePath = normalizedRelativePath(value, "source path");
-			else if (argument === "--managed") managedPath = portableOutputPath(value, "managed contract path");
-			else managedSourcePath = normalizedRelativePath(value, "managed source path");
+			if (!value) fail("--source requires a path.");
+			sourcePath = normalizedPath(value, "source path");
 			index += 1;
-			continue;
+		} else if (argument?.startsWith("-")) fail(`Unknown option '${argument}'.`);
+		else if (!argument || rootSeen) fail("Only one repository root may be provided.");
+		else {
+			root = argument;
+			rootSeen = true;
 		}
-		if (argument?.startsWith("-")) return fail(`Unknown option '${argument}'.`);
-		if (sawRoot || !argument) return fail("Only one repository root may be provided.");
-		root = argument;
-		sawRoot = true;
-	}
-	if (commandValue !== "build" && managedSourcePath) return fail("--managed-source is only valid for build.");
-	if (commandValue === "build" && managedPath && !managedSourcePath) return fail("--managed requires --managed-source when building.");
-	if (commandValue === "build" && collisionKey(indexPath) === collisionKey(sourcePath)) return fail("--index and --source must not be the same input and output path.");
-	if (commandValue === "build" && managedPath !== void 0 && managedSourcePath !== void 0 && collisionKey(managedPath) === collisionKey(managedSourcePath)) return fail("--managed and --managed-source must not be the same input and output path.");
+	}
 	return {
-		command: commandValue,
+		command,
 		root: path.resolve(root),
-		indexPath,
-		sourcePath,
-		...managedPath ? { managedPath } : {},
-		...managedSourcePath ? { managedSourcePath } : {}
+		sourcePath
 	};
 }
-function isRecord(value) {
-	return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+async function assertRoot(root) {
+	const anchored = await canonicalizeSystemTemporaryPrefix(root);
+	if (!await anchoredPathHasNoSymlink(anchored)) fail("repository root must not traverse a symbolic link.");
+	const metadata = await lstat(anchored);
+	if (!metadata.isDirectory() || metadata.isSymbolicLink()) fail("repository root must be a real directory.");
 }
-function exactKeys(value, expected, label) {
-	const actual = Object.keys(value).sort();
-	const sortedExpected = [...expected].sort();
-	if (JSON.stringify(actual) !== JSON.stringify(sortedExpected)) fail(`${label} must contain exactly: ${sortedExpected.join(", ")}.`);
-}
-function parseAuthoredCollection(value) {
-	if (!isRecord(value)) return fail("collection/source.json must be an object.");
-	exactKeys(value, [
-		"schema",
-		"localization",
-		"problems"
-	], "collection source");
-	if (value.schema !== SOURCE_SCHEMA) return fail(`collection source schema must be '${SOURCE_SCHEMA}'.`);
-	if (!isRecord(value.localization)) return fail("collection localization must be an object.");
-	exactKeys(value.localization, ["defaultLocale", "supportedLocales"], "collection localization");
-	if (value.localization.defaultLocale !== "zh-TW" || JSON.stringify(value.localization.supportedLocales) !== JSON.stringify(["zh-TW", "en"])) return fail("collection localization must declare zh-TW followed by en.");
-	if (!Array.isArray(value.problems) || value.problems.length < 1 || value.problems.length > 1e3) return fail("collection source must contain between 1 and 1000 problems.");
-	return {
-		schema: SOURCE_SCHEMA,
-		localization: {
-			defaultLocale: "zh-TW",
-			supportedLocales: ["zh-TW", "en"]
-		},
-		problems: value.problems.map((problemValue, index) => {
-			if (!isRecord(problemValue)) return fail(`collection source problem ${index + 1} must be an object.`);
-			exactKeys(problemValue, ["statementPaths", "bundlePath"], `collection source problem ${index + 1}`);
-			if (!isRecord(problemValue.statementPaths)) return fail(`problem ${index + 1} statementPaths must be an object.`);
-			exactKeys(problemValue.statementPaths, ["zh-TW", "en"], `problem ${index + 1} statementPaths`);
-			const statementPaths = {
-				"zh-TW": normalizedRelativePath(problemValue.statementPaths["zh-TW"], `problem ${index + 1} zh-TW statement`),
-				en: normalizedRelativePath(problemValue.statementPaths.en, `problem ${index + 1} English statement`)
-			};
-			if (!statementPaths["zh-TW"].endsWith(".md") || !statementPaths.en.endsWith(".md")) return fail(`problem ${index + 1} statements must be Markdown files.`);
-			return {
-				statementPaths,
-				bundlePath: normalizedRelativePath(problemValue.bundlePath, `problem ${index + 1} bundle`)
-			};
-		})
-	};
+function resolveInside(root, relative) {
+	return path.join(root, ...normalizedPath(relative, "repository path").split("/"));
 }
-function parseJson(bytes, label) {
-	let text;
+async function readFile(root, relative, maximum, expected) {
+	const absolute = resolveInside(root, relative);
+	if (!await anchoredPathHasNoSymlink(absolute)) fail(`'${relative}' must not traverse a symbolic link.`);
+	const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW);
 	try {
-		text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-	} catch (error) {
-		throw new Error(`${label} is not valid UTF-8.`, { cause: error });
+		const metadata = await handle.stat();
+		if (!metadata.isFile() || metadata.size < 1 || metadata.size > maximum || expected !== void 0 && metadata.size !== expected) fail(`'${relative}' has an invalid size.`);
+		return new Uint8Array(await handle.readFile());
+	} finally {
+		await handle.close();
 	}
+}
+function parseJson(bytes, label) {
 	try {
-		return JSON.parse(text);
+		return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
 	} catch (error) {
-		throw new Error(`${label} is not valid JSON.`, { cause: error });
+		throw new Error(`${label} must be valid UTF-8 JSON.`, { cause: error });
 	}
 }
-async function sha256Hex(bytes) {
+async function sha256(bytes) {
 	const digest = await crypto.subtle.digest("SHA-256", bytes.slice().buffer);
-	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function validatePublishedCollection(options, strict) {
-	const indexBytes = await readBoundedRepositoryFile(options, options.indexPath, "index path", INDEX_MAX_BYTES);
-	const index = parseProblemCollectionIndex$1(parseJson(indexBytes, options.indexPath));
-	await verifyProblemCollectionRevision$1(index);
-	if (strict && !Buffer.from(indexBytes).equals(Buffer.from(canonicalJsonBytes(index)))) fail(`${options.indexPath} is not canonical; run woj organizer collection build.`);
-	const indexDirectory = path.posix.dirname(options.indexPath);
-	for (const entry of index.problems) {
-		for (const [locale, statementPath] of Object.entries(entry.statementPaths)) if ((await readBoundedRepositoryFile(options, statementPath, `problem '${entry.id}' ${locale} statement`, STATEMENT_MAX_BYTES)).byteLength < 1) fail(`problem '${entry.id}' ${locale} statement must contain between 1 byte and 2 MiB.`);
-		const repositoryPath = path.posix.join(indexDirectory, entry.bundle.path);
-		const bytes = await readBoundedRepositoryFile(options, repositoryPath, `problem '${entry.id}' bundle`, PUBLIC_BUNDLE_MAX_BYTES, entry.bundle.bytes);
-		const problem = await verifyProblemBundleBytes$1(bytes, entry);
-		if (strict && !Buffer.from(bytes).equals(Buffer.from(canonicalJsonBytes({
-			schema: BROWSER_PROBLEM_SCHEMA$1,
-			problem
-		})))) fail(`${repositoryPath} is not canonical; run woj organizer collection build.`);
-	}
-	if (strict) await rejectUndeclaredContentAddressedBundles(options, index);
-	if (options.managedPath) await validateManagedContract(options, index);
-	return index;
-}
-async function validateManagedContract(options, index) {
-	const managedPath = options.managedPath;
-	if (!managedPath) fail("managed contract path is required.");
-	const contractBytes = await readBoundedRepositoryFile(options, managedPath, "managed contract path", MANAGED_MAX_BYTES);
-	const contract = parseManagedCollectionV2$1(contractBytes);
-	if (contract.collectionRevision !== index.revision) fail("managed collection revision does not match collection/index.json.");
-	if (JSON.stringify(contract.problems.map((problem) => problem.slug)) !== JSON.stringify(index.problems.map((problem) => problem.id))) fail("managed collection problems must exactly match index order.");
-	const indexDirectory = path.posix.dirname(options.indexPath);
-	for (const [position, publication] of contract.problems.entries()) {
-		const entry = index.problems[position];
-		const practiceBytes = await readBoundedRepositoryFile(options, path.posix.join(indexDirectory, entry.bundle.path), `problem '${entry.id}' bundle`, PUBLIC_BUNDLE_MAX_BYTES, entry.bundle.bytes);
-		const practice = await verifyProblemBundleBytes$1(practiceBytes, entry);
-		const contestBytes = await readPublishedObject(options, indexDirectory, publication.contestPublic, `contest-public '${publication.slug}'`, PUBLIC_BUNDLE_MAX_BYTES);
-		const expectedContestBytes = contestPublicProjectionBytes(practice, entry.bundle.sha256);
-		if (!Buffer.from(contestBytes).equals(Buffer.from(expectedContestBytes))) fail(`contest-public '${publication.slug}' is not the deterministic projection of its practice bundle.`);
-		const packageBytes = await readPublishedObject(options, indexDirectory, publication.judgePackage, `judge package '${publication.slug}'`, JUDGE_PACKAGE_MAX_BYTES);
-		const validatedPackage = await validateJudgePackage(packageBytes, {
-			expectedBytes: publication.judgePackage.bytes,
-			expectedSha256: publication.judgePackage.sha256,
-			memoryLimitBytes: Math.max(...practice.scoring.policies.map((policy) => policy.limits.memoryLimitBytes))
-		});
-		if (JSON.stringify(validatedPackage.manifest.allowedProfiles) !== JSON.stringify(publication.allowedProfiles)) fail(`judge package '${publication.slug}' allowedProfiles disagree with collection/managed.json.`);
-		assertJudgeDataMatchesPracticePublic(validatedPackage.judgeData, practice, Object.keys(publication.allowedProfiles));
-	}
+	return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-async function readPublishedObject(options, indexDirectory, object, label, maximumBytes) {
-	const bytes = await readBoundedRepositoryFile(options, path.posix.join(indexDirectory, object.repositoryPath), label, maximumBytes, object.bytes);
-	if (await sha256Hex(bytes) !== object.sha256) fail(`${label} failed integrity verification.`);
+async function readDeclared(root, object, label) {
+	const bytes = await readFile(root, object.path, PACKAGE_MAX_BYTES, object.bytes);
+	if (await sha256(bytes) !== object.sha256) fail(`${label} failed digest verification.`);
 	return bytes;
 }
-async function rejectUndeclaredContentAddressedBundles(options, index) {
-	const indexDirectory = path.posix.dirname(options.indexPath);
-	const relativeDirectory = path.posix.join(indexDirectory, "problems");
-	const directory = resolveInside(options.root, relativeDirectory, "bundle directory");
-	if (!await anchoredPathHasNoSymlink(directory)) fail("bundle directory must not traverse a symbolic link.");
-	const metadata = await lstat(directory);
-	if (metadata.isSymbolicLink() || !metadata.isDirectory()) fail("bundle directory must be a real directory.");
-	const declared = new Set(index.problems.map((entry) => path.posix.basename(entry.bundle.path)));
-	const entries = await readdir(directory, { withFileTypes: true });
-	const digestPattern = /\.[0-9a-f]{64}\.json$/;
-	const undeclared = entries.filter((entry) => entry.isFile() && digestPattern.test(entry.name) && !declared.has(entry.name)).map((entry) => entry.name).sort();
-	const unsafe = entries.filter((entry) => entry.isSymbolicLink() || !entry.isFile() && !entry.isDirectory()).map((entry) => entry.name).sort();
-	if (unsafe.length > 0) fail(`bundle directory contains unsafe entries: ${unsafe.join(", ")}.`);
-	if (undeclared.length > 0) fail(`undeclared content-addressed bundles: ${undeclared.join(", ")}.`);
-}
-function assertGeneratedSize(bytes, maximumBytes, label) {
-	if (bytes.byteLength > maximumBytes) fail(`${label} exceeds its allowed byte limit.`);
-}
-async function prepareCollection(options) {
-	const source = parseAuthoredCollection(parseJson(await readBoundedRepositoryFile(options, options.sourcePath, "source path", COLLECTION_SOURCE_MAX_BYTES), options.sourcePath));
-	const indexDirectory = path.posix.dirname(options.indexPath);
-	const entries = [];
-	const authoredProblems = [];
-	const practiceProblems = [];
-	const inputs = /* @__PURE__ */ new Set([options.sourcePath]);
-	const outputs = [];
-	for (const [position, authored] of source.problems.entries()) {
-		inputs.add(authored.bundlePath);
-		const authoredBytes = await readBoundedRepositoryFile(options, authored.bundlePath, `problem ${position + 1} source bundle`, AUTHORING_BUNDLE_MAX_BYTES);
-		const problem = parseStandaloneProblemBundle$1(parseJson(authoredBytes, authored.bundlePath));
-		if (problem.number !== position + 1) fail(`problem '${problem.id}' must have number ${position + 1}.`);
-		for (const [locale, statementPath] of Object.entries(authored.statementPaths)) {
-			inputs.add(statementPath);
-			if ((await readBoundedRepositoryFile(options, statementPath, `problem '${problem.id}' ${locale} statement`, STATEMENT_MAX_BYTES)).byteLength < 1) fail(`problem '${problem.id}' ${locale} statement must contain between 1 byte and 2 MiB.`);
-		}
-		authoredProblems.push(problem);
-		const practice = derivePracticePublic(problem);
-		practiceProblems.push(practice);
-		const bundleBytes = canonicalJsonBytes({
-			schema: BROWSER_PROBLEM_SCHEMA$1,
-			problem: practice
-		});
-		assertGeneratedSize(bundleBytes, PUBLIC_BUNDLE_MAX_BYTES, `problem '${problem.id}' public bundle`);
-		const digest = await sha256Hex(bundleBytes);
-		const bundleName = `${String(problem.number).padStart(3, "0")}-${problem.id}.${digest}.json`;
-		outputs.push({
-			path: path.posix.join(indexDirectory, "problems", bundleName),
-			label: `problem '${problem.id}' public bundle output`,
-			bytes: bundleBytes
-		});
-		entries.push({
-			id: problem.id,
-			number: problem.number,
-			title: problem.title,
-			trackId: problem.trackId,
-			track: problem.track,
-			statementPaths: authored.statementPaths,
-			difficulty: problem.difficulty,
-			tags: problem.tags,
-			caseCount: practice.judgeCases.length,
-			bundle: {
-				path: `problems/${bundleName}`,
-				sha256: digest,
-				bytes: bundleBytes.byteLength
-			}
-		});
-	}
-	const withoutRevision = {
-		schema: BROWSER_COLLECTION_SCHEMA$1,
-		problemSchema: BROWSER_PROBLEM_SCHEMA$1,
-		localization: source.localization,
-		problems: entries
-	};
-	const index = parseProblemCollectionIndex$1({
-		...withoutRevision,
-		revision: await problemCollectionRevision$1(withoutRevision)
-	});
-	const indexBytes = canonicalJsonBytes(index);
-	assertGeneratedSize(indexBytes, INDEX_MAX_BYTES, "collection index output");
-	outputs.push({
-		path: options.indexPath,
-		label: "collection index output",
-		bytes: indexBytes
-	});
-	return {
-		index,
-		authoredProblems,
-		practiceProblems,
-		inputs,
-		outputs
-	};
-}
-async function readDeclaredManagedSourceObject(options, object, label, inputs) {
-	inputs.add(object.path);
-	const bytes = await readBoundedRepositoryFile(options, object.path, label, JUDGE_PACKAGE_MAX_BYTES, object.bytes);
-	if (await sha256Hex(bytes) !== object.sha256) fail(`${label} failed declared size or digest verification.`);
-	return bytes;
-}
-async function managedJudgeInput(options, problem, inputs) {
-	if (problem.judge.kind === "text") return { kind: "text" };
-	const artifact = await readDeclaredManagedSourceObject(options, problem.judge.artifact, `${problem.judge.kind} artifact '${problem.slug}'`, inputs);
+async function judgeInput(root, judge) {
+	if (judge.kind === "text") return { kind: "text" };
+	const artifact = await readDeclared(root, judge.artifact, `${judge.kind} artifact`);
 	const assets = [];
-	for (const asset of problem.judge.assets) assets.push({
+	for (const asset of judge.assets) assets.push({
 		guestPath: asset.guestPath,
-		contents: await readDeclaredManagedSourceObject(options, asset, `${problem.judge.kind} asset '${problem.slug}/${asset.path}'`, inputs)
+		contents: await readDeclared(root, asset, `${judge.kind} asset`)
 	});
-	return problem.judge.kind === "checker" ? {
+	return judge.kind === "checker" ? {
 		kind: "checker",
-		runtimeProfile: problem.judge.artifact.runtimeProfile,
+		runtimeProfile: judge.artifact.runtimeProfile,
 		artifact,
 		assets,
-		args: problem.judge.args
+		args: judge.args
 	} : {
 		kind: "interactive",
-		runtimeProfile: problem.judge.artifact.runtimeProfile,
+		runtimeProfile: judge.artifact.runtimeProfile,
 		artifact,
 		assets,
-		args: problem.judge.args,
-		inputPath: problem.judge.inputPath
+		args: judge.args,
+		inputPath: judge.inputPath
+	};
+}
+function localized(value, label, empty) {
+	const input = record(value, label);
+	exact(input, ["en", "zh-TW"], label);
+	if (typeof input.en !== "string" || typeof input["zh-TW"] !== "string" || !empty && (!input.en.trim() || !input["zh-TW"].trim())) fail(`${label} must contain zh-TW and en strings.`);
+	return {
+		"zh-TW": input["zh-TW"],
+		en: input.en
+	};
+}
+function parseAuthoringSource(value) {
+	const source = record(value, "repository authoring source");
+	exact(source, [
+		"contests",
+		"problems",
+		"schema"
+	], "repository authoring source");
+	if (source.schema !== AUTHORING_SCHEMA || !Array.isArray(source.problems)) fail(`repository authoring schema must be '${AUTHORING_SCHEMA}'.`);
+	const judgeSource = parseRepositoryAuthoringJudges({
+		schema: "wasm-oj-platform/repository-authoring-judges/v1",
+		problems: source.problems.map((candidate) => {
+			const problem = record(candidate, "authoring problem");
+			return {
+				slug: problem.slug,
+				allowedProfiles: problem.allowedProfiles,
+				judge: problem.judge
+			};
+		})
+	});
+	const problems = source.problems.map((candidate, index) => {
+		const problem = record(candidate, `authoring problem ${index + 1}`);
+		exact(problem, [
+			"allowedProfiles",
+			"authoringBundle",
+			"judge",
+			"order",
+			"practiceEnabled",
+			"slug",
+			"summary",
+			"title"
+		], `authoring problem ${index + 1}`);
+		if (!Number.isSafeInteger(problem.order) || problem.order !== index + 1 || typeof problem.practiceEnabled !== "boolean") fail(`authoring problem ${index + 1} order or practiceEnabled is invalid.`);
+		const parsedJudge = judgeSource.problems[index];
+		return {
+			slug: parsedJudge.slug,
+			order: problem.order,
+			title: localized(problem.title, `authoring problem '${parsedJudge.slug}' title`, false),
+			summary: localized(problem.summary, `authoring problem '${parsedJudge.slug}' summary`, true),
+			practiceEnabled: problem.practiceEnabled,
+			authoringBundle: normalizedPath(problem.authoringBundle, `authoring problem '${parsedJudge.slug}' bundle`),
+			allowedProfiles: parsedJudge.allowedProfiles,
+			judge: parsedJudge.judge
+		};
+	});
+	if (!Array.isArray(source.contests)) fail("repository authoring source contests must be an array.");
+	const contests = parseRepositoryContestsValue({
+		schema: "wasm-oj-platform/contests/v2",
+		contests: source.contests.map((candidate, index) => {
+			const contest = record(candidate, `authoring contest ${index + 1}`);
+			exact(contest, [
+				"accessMode",
+				"description",
+				"rules",
+				"slug",
+				"status",
+				"title"
+			], `authoring contest ${index + 1}`);
+			const rulesInput = record(contest.rules, `authoring contest ${index + 1} rules`);
+			const rules = Object.hasOwn(rulesInput, "preset") ? expandContestRulesPreset(parseContestRulesPreset(rulesInput, `authoring contest ${index + 1} rules`)) : parseContestRules(rulesInput, `authoring contest ${index + 1} rules`);
+			return {
+				...contest,
+				rules
+			};
+		})
+	}).contests;
+	const known = new Set(problems.map((problem) => problem.slug));
+	for (const contest of contests) for (const problem of contest.rules.problems) if (!known.has(problem.slug)) fail(`contest '${contest.slug}' references unknown problem '${problem.slug}'.`);
+	return {
+		problems,
+		contests
 	};
 }
-async function prepareManagedCollection(options, built) {
-	const managedSourcePath = options.managedSourcePath;
-	if (!managedSourcePath) fail("managed source path is required.");
-	const inputs = /* @__PURE__ */ new Set([managedSourcePath]);
+async function atomicWrite(root, output) {
+	const absolute = resolveInside(root, output.path);
+	const parent = path.dirname(absolute);
+	await mkdir(parent, { recursive: true });
+	if (!await anchoredPathHasNoSymlink(parent)) fail(`output parent for '${output.path}' must not traverse a symbolic link.`);
+	const temporary = `${absolute}.${process.pid}.${crypto.randomUUID()}.tmp`;
+	try {
+		await writeFile(temporary, output.bytes, {
+			flag: "wx",
+			mode: 420
+		});
+		await rename(temporary, absolute);
+	} finally {
+		await rm(temporary, { force: true });
+	}
+}
+async function build(options) {
+	const source = parseAuthoringSource(parseJson(await readFile(options.root, options.sourcePath, JSON_MAX_BYTES), options.sourcePath));
+	const problems = [];
 	const outputs = [];
-	const sourceBytes = await readBoundedRepositoryFile(options, managedSourcePath, "managed source path", MANAGED_MAX_BYTES);
-	const source = parseManagedCollectionSource$1(parseJson(sourceBytes, managedSourcePath));
-	if (JSON.stringify(source.problems.map((problem) => problem.slug)) !== JSON.stringify(built.index.problems.map((problem) => problem.id))) fail("managed source problems must exactly match collection/index.json order.");
-	const indexDirectory = path.posix.dirname(options.indexPath);
-	const publicationDirectory = path.posix.join(indexDirectory, "managed");
-	const publications = [];
-	for (const [position, sourceProblem] of source.problems.entries()) {
-		const entry = built.index.problems[position];
-		const practice = built.practiceProblems[position];
-		const authored = built.authoredProblems[position];
-		if (!authored || authored.id !== entry.id) fail(`authoring source for '${entry.id}' is unavailable.`);
-		const contestBytes = contestPublicProjectionBytes(practice, entry.bundle.sha256);
-		assertGeneratedSize(contestBytes, PUBLIC_BUNDLE_MAX_BYTES, `contest-public '${entry.id}' output`);
-		const contestSha256 = await sha256Hex(contestBytes);
-		const contestName = `${String(entry.number).padStart(3, "0")}-${entry.id}.${contestSha256}.contest.json`;
-		outputs.push({
-			path: path.posix.join(publicationDirectory, contestName),
-			label: `contest-public '${entry.id}' output`,
-			bytes: contestBytes
+	for (const authored of source.problems) {
+		const bundle = parseStandaloneProblemBundle$1(parseJson(await readFile(options.root, authored.authoringBundle, PACKAGE_MAX_BYTES), authored.authoringBundle));
+		if (bundle.id !== authored.slug || bundle.number !== authored.order || !sameLocalizedText(bundle.title, authored.title)) fail(`authoring bundle '${authored.slug}' disagrees with its declarative identity.`);
+		const practice = derivePracticePublic(bundle);
+		const practiceBytes = canonicalJsonBytes({
+			schema: BROWSER_PROBLEM_SCHEMA$1,
+			problem: practice
 		});
+		const practiceDigest = await sha256(practiceBytes);
+		const contestBytes = contestPublicProjectionBytes(practice);
 		const encoded = await encodeJudgePackage({
-			judgeData: deriveJudgeData(authored, Object.keys(sourceProblem.allowedProfiles)),
-			allowedProfiles: sourceProblem.allowedProfiles,
-			judge: await managedJudgeInput(options, sourceProblem, inputs)
+			judgeData: deriveJudgeData(bundle, Object.keys(authored.allowedProfiles)),
+			allowedProfiles: authored.allowedProfiles,
+			judge: await judgeInput(options.root, authored.judge)
 		});
-		assertGeneratedSize(encoded.bytes, JUDGE_PACKAGE_MAX_BYTES, `judge package '${entry.id}' output`);
-		const validated = await validateJudgePackage(encoded.bytes, {
-			expectedBytes: encoded.bytes.byteLength,
-			expectedSha256: encoded.executionSemanticSha256,
-			memoryLimitBytes: Math.max(...practice.scoring.policies.map((policy) => policy.limits.memoryLimitBytes))
-		});
-		assertJudgeDataMatchesPracticePublic(validated.judgeData, practice, Object.keys(sourceProblem.allowedProfiles));
-		const packageName = `${String(entry.number).padStart(3, "0")}-${entry.id}.${encoded.executionSemanticSha256}.wasmojjudge`;
+		const base = `collection/problems/${String(authored.order).padStart(3, "0")}-${authored.slug}`;
+		const practicePath = `${base}.practice.json`;
+		const contestPath = `${base}.contest.json`;
+		const judgePath = `${base}.wasmojjudge`;
 		outputs.push({
-			path: path.posix.join(publicationDirectory, packageName),
-			label: `judge package '${entry.id}' output`,
+			path: practicePath,
+			bytes: practiceBytes
+		}, {
+			path: contestPath,
+			bytes: contestBytes
+		}, {
+			path: judgePath,
 			bytes: encoded.bytes
 		});
-		publications.push({
-			slug: entry.id,
-			allowedProfiles: sourceProblem.allowedProfiles,
-			contestPublic: {
-				repositoryPath: `managed/${contestName}`,
+		problems.push({
+			slug: authored.slug,
+			order: authored.order,
+			title: authored.title,
+			summary: authored.summary,
+			practiceEnabled: authored.practiceEnabled,
+			practiceBundle: {
+				path: practicePath,
+				bytes: practiceBytes.byteLength,
+				sha256: practiceDigest
+			},
+			contestBundle: {
+				path: contestPath,
 				bytes: contestBytes.byteLength,
-				sha256: contestSha256
+				sha256: await sha256(contestBytes)
 			},
 			judgePackage: {
-				repositoryPath: `managed/${packageName}`,
+				path: judgePath,
 				bytes: encoded.bytes.byteLength,
 				sha256: encoded.executionSemanticSha256
 			}
 		});
 	}
-	const contract = parseManagedCollectionV2$1(canonicalJsonBytes({
-		schema: MANAGED_COLLECTION_SCHEMA$1,
-		collectionRevision: built.index.revision,
-		problems: publications
-	}));
-	const managedPath = options.managedPath ?? path.posix.join(indexDirectory, "managed.json");
-	const contractBytes = canonicalJsonBytes(contract);
-	assertGeneratedSize(contractBytes, MANAGED_MAX_BYTES, "managed contract output");
+	const problemManifest = {
+		schema: "wasm-oj-platform/problems/v1",
+		problems
+	};
+	parseRepositoryProblemsValue(problemManifest);
+	const contestManifest = {
+		schema: "wasm-oj-platform/contests/v2",
+		contests: source.contests
+	};
+	parseRepositoryContestsValue(contestManifest);
+	const root = {
+		schema: "wasm-oj-platform/repository/v1",
+		problems: PROBLEMS_PATH,
+		contests: CONTESTS_PATH
+	};
+	parseRepositoryRootValue(root);
 	outputs.push({
-		path: managedPath,
-		label: "managed contract output",
-		bytes: contractBytes
+		path: PROBLEMS_PATH,
+		bytes: canonicalJsonBytes(problemManifest)
+	}, {
+		path: CONTESTS_PATH,
+		bytes: canonicalJsonBytes(contestManifest)
+	}, {
+		path: ROOT_PATH,
+		bytes: canonicalJsonBytes(root)
 	});
-	return {
-		inputs,
-		outputs
-	};
+	for (const output of outputs) await atomicWrite(options.root, output);
+	return problems.length;
 }
-function pathsOverlap(left, right) {
-	const leftKey = collisionKey(left);
-	const rightKey = collisionKey(right);
-	return leftKey === rightKey || leftKey.startsWith(`${rightKey}/`) || rightKey.startsWith(`${leftKey}/`);
+async function verifiedObject(root, descriptor, maximum) {
+	const bytes = await readFile(root, descriptor.path, maximum, descriptor.bytes);
+	if (await sha256(bytes) !== descriptor.sha256) fail(`'${descriptor.path}' failed digest verification.`);
+	return bytes;
 }
-async function writePreparedCollection(options, inputs, outputs) {
-	const outputPaths = /* @__PURE__ */ new Set();
-	for (const output of outputs) {
-		portableOutputPath(output.path, output.label);
-		const key = collisionKey(output.path);
-		if (outputPaths.has(key)) fail(`generated output '${output.path}' has a case-folded or normalized collision.`);
-		outputPaths.add(key);
-		for (const input of inputs) if (pathsOverlap(input, output.path)) fail(`generated output '${output.path}' overlaps declared input '${input}'.`);
+async function verify(options) {
+	const root = parseRepositoryRootValue(parseJson(await readFile(options.root, ROOT_PATH, JSON_MAX_BYTES), ROOT_PATH));
+	const problems = parseRepositoryProblemsValue(parseJson(await readFile(options.root, root.problems, JSON_MAX_BYTES), root.problems));
+	const contests = parseRepositoryContestsValue(parseJson(await readFile(options.root, root.contests, JSON_MAX_BYTES), root.contests));
+	const known = new Set(problems.problems.map((problem) => problem.slug));
+	for (const contest of contests.contests) for (const problem of contest.rules.problems) if (!known.has(problem.slug)) fail(`contest '${contest.slug}' references unknown problem '${problem.slug}'.`);
+	for (const problem of problems.problems) {
+		const practiceBytes = await verifiedObject(options.root, problem.practiceBundle, PUBLIC_MAX_BYTES);
+		const practice = parseStandaloneProblemBundle$1(parseJson(practiceBytes, problem.practiceBundle.path));
+		if (practice.id !== problem.slug || practice.number !== problem.order || !sameLocalizedText(practice.title, problem.title)) fail(`practice bundle '${problem.slug}' disagrees with problems.json.`);
+		const contest = parseContestPublicProblemProjection(parseJson(await verifiedObject(options.root, problem.contestBundle, PUBLIC_MAX_BYTES), problem.contestBundle.path));
+		const expectedContest = canonicalJsonBytes(deriveContestPublic(practice));
+		if (!Buffer.from(canonicalJsonBytes(contest.problem)).equals(Buffer.from(expectedContest))) fail(`contest bundle '${problem.slug}' is not the public projection of its practice bundle.`);
+		const packageBytes = await verifiedObject(options.root, problem.judgePackage, PACKAGE_MAX_BYTES);
+		const validated = await validateJudgePackage(packageBytes, {
+			expectedBytes: problem.judgePackage.bytes,
+			expectedSha256: problem.judgePackage.sha256,
+			memoryLimitBytes: Math.max(...practice.scoring.policies.map((policy) => policy.limits.memoryLimitBytes))
+		});
+		assertJudgeDataMatchesPracticePublic(validated.judgeData, practice, Object.keys(validated.manifest.allowedProfiles));
 	}
-	await assertNoFilesystemAliases(options, inputs, outputs.map((output) => output.path));
-	await Promise.all(outputs.map((output) => assertOutputPathSafe(options, output.path, output.label)));
-	for (const output of outputs) await atomicRepositoryWrite(options, output.path, output.bytes);
+	return problems.problems.length;
 }
 async function runCollectionCli(arguments_) {
 	const options = parseOptions(arguments_);
-	await assertRepositoryRoot(options.root);
-	let index;
-	if (options.command === "build") {
-		const initialManagedOutput = options.managedSourcePath ? options.managedPath ?? path.posix.join(path.posix.dirname(options.indexPath), "managed.json") : void 0;
-		await assertNoFilesystemAliases(options, /* @__PURE__ */ new Set([options.sourcePath, ...options.managedSourcePath ? [options.managedSourcePath] : []]), [options.indexPath, ...initialManagedOutput ? [initialManagedOutput] : []]);
-		const built = await prepareCollection(options);
-		index = built.index;
-		const managed = options.managedSourcePath ? await prepareManagedCollection(options, built) : void 0;
-		await writePreparedCollection(options, /* @__PURE__ */ new Set([...built.inputs, ...managed?.inputs ?? []]), [...built.outputs, ...managed?.outputs ?? []]);
-	} else index = await validatePublishedCollection(options, true);
-	process.stdout.write(`${options.command} ok: ${index.problems.length} problems, revision ${index.revision}\n`);
+	await assertRoot(options.root);
+	const count = options.command === "build" ? await build(options) : await verify(options);
+	process.stdout.write(`${options.command} ok: ${count} problems\n`);
 }
 if (process.argv[1] ? import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href : false) runCollectionCli(process.argv.slice(2)).catch((error) => {
 	process.stderr.write(`woj organizer collection: ${error instanceof Error ? error.message : String(error)}\n`);
 	process.exitCode = 1;
 });
 //#endregion
-export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, MANAGED_COLLECTION_SCHEMA, parseManagedCollectionContract, parseManagedCollectionSource, parseManagedCollectionV2, parseManagedCollectionValueV2, parseProblemCollectionIndex, parseStandaloneProblemBundle, problemCollectionRevision, runCollectionCli, verifyProblemBundleBytes, verifyProblemCollectionRevision };
+export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, CONTESTS_SCHEMA, PROBLEMS_SCHEMA, REPOSITORY_AUTHORING_JUDGES_SCHEMA, REPOSITORY_SCHEMA, parseProblemCollectionIndex, parseRepositoryAuthoringJudges, parseRepositoryContests, parseRepositoryContestsValue, parseRepositoryProblems, parseRepositoryProblemsValue, parseRepositoryRoot, parseRepositoryRootValue, parseStandaloneProblemBundle, problemCollectionRevision, runCollectionCli, validateRepositoryCatalog, verifyProblemBundleBytes, verifyProblemCollectionRevision };