@wasm-oj/core 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -28,7 +28,6 @@ declare const WASM_OJ_SCHEMAS: Readonly<{
     readonly objectCache: "wasm-oj-v2/object-cache";
     readonly pythonToolchain: "wasm-oj-v2/python-toolchain";
     readonly replayBundle: "wasm-oj-v2/replay-bundle";
-    readonly releaseManifest: "wasm-oj-v2/release-manifest";
     readonly rustToolchain: "wasm-oj-v2/rust-toolchain";
     readonly runRequest: "wasm-oj-v2/run-request";
     readonly runtimeBundle: "wasm-oj-v2/runtime-bundle";
@@ -351,8 +350,8 @@ declare function isCostProfileFor(profile: string, language: Language, target: T
 
 /** Executable runtime components covered by deterministic cost calibration. */
 declare const WASM_OJ_RUNTIME_COMPONENTS: Readonly<{
-    readonly runtimeCoreWasmSha256: "92500f3a2e65fe6979e893179d8000e12d66822c160eeb779b0d4fe0a6b55603";
-    readonly runtimeSourceRootSha256: "3ef42cb2c70e7013e4a6f9d4d7457a7071101795fbd3753efcd20c1ac338ebd5";
+    readonly runtimeCoreWasmSha256: "e4c7fca566ff5ba66931e0cf11cacbf37610d35c36d5f3ee97d719468a2f6466";
+    readonly runtimeSourceRootSha256: "0140ecc6ed5060eae465e73db6822bcde32295734517de84929a537e3c45e663";
     readonly wasmerNativeVersion: "7.2.1";
     readonly wasmerSdkVersion: "0.10.0";
     readonly wasmerSdkWasmSha256: "49a6646209f5ab5e7c737eac33407d87d9a9959ac83e5ecaaab9261b2323589e";
@@ -363,94 +362,11 @@ declare const WASM_OJ_RUNTIME_COMPONENTS: Readonly<{
  * Release verification independently checks the component bytes before this
  * identity is admitted into a calibrated release.
  */
-declare const WASM_OJ_RUNTIME_IDENTITY_SHA256 = "24c0bcff9820fbfd1fd4db1c57e2a866b83041409dd22b5b725688739bd3e223";
+declare const WASM_OJ_RUNTIME_IDENTITY_SHA256 = "59414bf4fa5191d0942c0e190c69d32f3a2251461b8eb41aaba32598baab1d5f";
 /** Exact canonical serialization hashed by `WASM_OJ_RUNTIME_IDENTITY_SHA256`. */
 declare function runtimeIdentityBytes(): Uint8Array;
 declare function verifyRuntimeIdentity(): Promise<void>;
 
-declare const WASM_OJ_RELEASE_MANIFEST_SCHEMA: "wasm-oj-v2/release-manifest";
-declare const WASM_OJ_CONTAINER_PROTOCOL_VERSION = "wasm-oj-container-v2";
-interface ReleaseManifest {
-    readonly schema: typeof WASM_OJ_RELEASE_MANIFEST_SCHEMA;
-    readonly releaseId: string;
-    readonly version: string;
-    readonly wasmOjContract: typeof WASM_OJ_CONTRACT_VERSION;
-    readonly createdAt: string;
-    readonly source: {
-        readonly repository: string;
-        readonly commit: string;
-        readonly sourceTreeSha256: string;
-        readonly tag?: string;
-    };
-    readonly build: {
-        readonly nodeVersion: string;
-        readonly pnpmVersion: string;
-        readonly rustVersion: string;
-        readonly lockSha256: string;
-        readonly sbomSha256: string;
-        readonly licensesSha256: string;
-        readonly auditSha256: string;
-    };
-    readonly artifacts: {
-        readonly npmPackage: ArtifactDigest;
-        readonly workerBundle: ArtifactDigest;
-        readonly staticAssets: ArtifactDigest;
-        readonly containerImage: {
-            readonly registry: string;
-            readonly digest: string;
-            readonly identitySha256: string;
-            readonly platform: "linux/amd64";
-            readonly dockerfileSha256: string;
-            readonly baseImages: readonly {
-                readonly stage: "node-build" | "rust-build" | "judge";
-                readonly image: string;
-                readonly digest: string;
-            }[];
-        };
-    };
-    readonly runtime: {
-        readonly protocolVersion: typeof WASM_OJ_CONTAINER_PROTOCOL_VERSION;
-        readonly executionRootSha256: string;
-        readonly rootSha256: string;
-        readonly runtimeIdentitySha256: string;
-        readonly runtimeCoreSha256: string;
-        readonly wasmerVersion: string;
-        readonly wasmerSha256: string;
-        readonly compilerSha256: string;
-        readonly runnerSha256: string;
-    };
-    readonly toolchains: {
-        readonly rootSha256: string;
-        readonly manifestSha256: string;
-    };
-    readonly cost: {
-        readonly model: typeof WEIGHTED_METER_MODEL;
-        readonly profileRootSha256: string;
-        readonly baselineSha256: string;
-    };
-    readonly evidence: {
-        readonly conformanceSha256: string;
-        readonly testsSha256: string;
-        readonly costCalibrationSha256: string;
-    };
-    readonly migrations: {
-        readonly databaseSha256: string;
-    };
-    readonly provenance: {
-        readonly issuer: string;
-        readonly subject: string;
-    };
-}
-interface ArtifactDigest {
-    readonly sha256: string;
-    readonly bytes: number;
-}
-declare function parseReleaseManifest(value: unknown): ReleaseManifest;
-declare function createReleaseManifest(value: ReleaseManifest): ReleaseManifest;
-declare function releaseManifestBytes(value: ReleaseManifest): Uint8Array;
-declare function releaseManifestSha256(value: ReleaseManifest): Promise<string>;
-declare function verifyReleaseManifestBytes(bytes: Uint8Array, expectedSha256?: string): Promise<ReleaseManifest>;
-
 /**
  * Fail-closed validation boundary for projects crossing persistence or
  * transport boundaries. The candidate is checked without mutation, defaults,
@@ -1640,58 +1556,28 @@ declare function scoreProblemResults(problem: JudgeProblem, language: BuiltinLan
 /** Score immutable execution-only judge data without reconstructing a public problem bundle. */
 declare function scoreJudgeDataResults(data: JudgeData, language: BuiltinLanguage$1, results: readonly JudgeCaseResult[]): ProblemScore;
 
-interface JudgeAllowedProfile {
-    readonly target: "wasip1" | "wasix";
-    readonly optimization: "debug" | "release";
-}
-type JudgeAllowedProfiles = Readonly<Partial<Record<BuiltinLanguage, JudgeAllowedProfile>>>;
-declare function parseJudgeAllowedProfiles(value: unknown, label?: string): JudgeAllowedProfiles;
-
-declare const MANAGED_COLLECTION_SCHEMA = "wasm-oj-platform/managed-collection/v2";
-interface ManagedRepositoryObject {
-    /** Normalized path relative to the directory containing collection/index.json. */
-    readonly repositoryPath: string;
-    readonly bytes: number;
-    readonly sha256: string;
-}
-interface ManagedProblemPublication {
-    readonly slug: string;
-    readonly allowedProfiles: JudgeAllowedProfiles;
-    readonly contestPublic: ManagedRepositoryObject;
-    readonly judgePackage: ManagedRepositoryObject;
-}
-interface ManagedCollectionV2 {
-    readonly schema: typeof MANAGED_COLLECTION_SCHEMA;
-    readonly collectionRevision: string;
-    readonly problems: readonly ManagedProblemPublication[];
-}
-/** Parse the value form used by the authoring CLI after JSON decoding. */
-declare function parseManagedCollectionValueV2(value: unknown): ManagedCollectionV2;
-/**
- * Stable platform boundary for generated collection/managed.json bytes.
- * Published managed contracts must use WASM-OJ canonical JSON; author-only
- * managed-source documents are intentionally not accepted here.
- */
-declare function parseManagedCollectionV2(bytes: Uint8Array): ManagedCollectionV2;
-/** Same v2-only value parser retained as the environment-neutral library entry point. */
-declare const parseManagedCollectionContract: typeof parseManagedCollectionValueV2;
-
 declare const CONTEST_PUBLIC_PROJECTION_SCHEMA = "wasm-oj-platform/contest-public-problem-projection/v1";
 interface ContestPublicProjection {
     readonly schema: typeof CONTEST_PUBLIC_PROJECTION_SCHEMA;
     readonly problem: JudgeProblem;
-    readonly digest: string;
 }
 /**
- * The bundle referenced by collection/index.json is safe to fetch for every
- * practice visitor. Hidden cases and their expected answers exist only in the
- * immutable judge package built from the authoring source.
+ * The repository practice bundle is safe to fetch for every practice visitor.
+ * Hidden cases and their expected answers exist only in the immutable judge
+ * package built from the authoring source.
  */
 declare function derivePracticePublic(authored: JudgeProblem): JudgeProblem;
 /** The single deterministic hidden-data redaction used by author CI and platform validation. */
 declare function deriveContestPublic(practice: JudgeProblem): JudgeProblem;
-declare function createContestPublicProjection(practice: JudgeProblem, problemBundleSha256: string): ContestPublicProjection;
-declare function contestPublicProjectionBytes(practice: JudgeProblem, problemBundleSha256: string): Uint8Array;
+declare function createContestPublicProjection(practice: JudgeProblem): ContestPublicProjection;
+declare function contestPublicProjectionBytes(practice: JudgeProblem): Uint8Array;
+
+interface JudgeAllowedProfile {
+    readonly target: "wasip1" | "wasix";
+    readonly optimization: "debug" | "release";
+}
+type JudgeAllowedProfiles = Readonly<Partial<Record<BuiltinLanguage, JudgeAllowedProfile>>>;
+declare function parseJudgeAllowedProfiles(value: unknown, label?: string): JudgeAllowedProfiles;
 
 declare const WASM_OJ_JUDGE_PACKAGE_SCHEMA = "wasm-oj-v2/judge-package";
 declare const WASM_OJ_JUDGE_PACKAGE_MAGIC = "WOJJDG02";
@@ -1808,43 +1694,43 @@ declare function decodeJudgePackageForExecution(bytes: Uint8Array): Promise<Deco
 /** Execution identity is the digest of the exact canonical WOJJDG02 bytes. */
 declare function judgePackageSemanticDigest(bytes: Uint8Array): Promise<string>;
 
-declare const MANAGED_COLLECTION_SOURCE_SCHEMA = "wasm-oj-platform/managed-collection-source/v1";
-interface ManagedSourceObject {
+declare const REPOSITORY_AUTHORING_JUDGES_SCHEMA = "wasm-oj-platform/repository-authoring-judges/v1";
+interface RepositorySourceObject {
     readonly path: string;
     readonly bytes: number;
     readonly sha256: string;
 }
-interface ManagedSourceArtifact extends ManagedSourceObject {
+interface RepositorySourceArtifact extends RepositorySourceObject {
     readonly runtimeProfile: TrustedJudgeRuntimeProfile;
 }
-interface ManagedSourceAsset extends ManagedSourceObject {
+interface RepositorySourceAsset extends RepositorySourceObject {
     readonly guestPath: string;
 }
-type ManagedSourceJudge = {
+type RepositorySourceJudge = {
     readonly kind: "text";
 } | {
     readonly kind: "checker";
-    readonly artifact: ManagedSourceArtifact;
-    readonly assets: readonly ManagedSourceAsset[];
+    readonly artifact: RepositorySourceArtifact;
+    readonly assets: readonly RepositorySourceAsset[];
     readonly args: readonly string[];
 } | {
     readonly kind: "interactive";
-    readonly artifact: ManagedSourceArtifact;
-    readonly assets: readonly ManagedSourceAsset[];
+    readonly artifact: RepositorySourceArtifact;
+    readonly assets: readonly RepositorySourceAsset[];
     readonly args: readonly string[];
     readonly inputPath: string;
 };
-interface ManagedCollectionSourceProblem {
+interface RepositoryAuthoringJudgeProblem {
     readonly slug: string;
     readonly allowedProfiles: JudgeAllowedProfiles;
-    readonly judge: ManagedSourceJudge;
+    readonly judge: RepositorySourceJudge;
 }
-interface ManagedCollectionSource {
-    readonly schema: typeof MANAGED_COLLECTION_SOURCE_SCHEMA;
-    readonly problems: readonly ManagedCollectionSourceProblem[];
+interface RepositoryAuthoringJudges {
+    readonly schema: typeof REPOSITORY_AUTHORING_JUDGES_SCHEMA;
+    readonly problems: readonly RepositoryAuthoringJudgeProblem[];
 }
-/** Author-only parser. Platform publication parsers must never call this API. */
-declare function parseManagedCollectionSource(value: unknown): ManagedCollectionSource;
+/** Author-only input used by collection build; never accepted by the platform sync boundary. */
+declare function parseRepositoryAuthoringJudges(value: unknown): RepositoryAuthoringJudges;
 
 /** Build the runtime judge spec directly from verified WOJJDG02 execution data. */
 declare function trustedJudgeSpec(data: JudgeData, executable: TrustedJudgeExecutable): JudgeSpec;
@@ -1879,5 +1765,5 @@ declare const DEFAULT_CONFORMANCE_CASES: readonly ConformanceCase[];
 declare const CPP_STDLIB_CONFORMANCE_CASE: ConformanceCase;
 declare const FULL_CONFORMANCE_CASES: readonly ConformanceCase[];
 
-export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, BrowserDependencyNetworkConsent, CONTEST_PUBLIC_PROJECTION_SCHEMA, CPP_STDLIB_CONFORMANCE_CASE, CargoLockDependencyResolver, CompilerRegistry, CostBaselineRegistry, CppLockDependencyResolver, DEFAULT_CONFORMANCE_CASES, DEFAULT_DETERMINISM, DEFAULT_RESOURCE_POLICY, DEPENDENCY_BUILD_LIMITS, DependencyManager, DependencyNetworkError, Engine, FULL_CONFORMANCE_CASES, GoLockDependencyResolver, JudgeEngine, MANAGED_COLLECTION_SCHEMA, MANAGED_COLLECTION_SOURCE_SCHEMA, MemoryDependencyCache, NpmLockDependencyResolver, PROBLEM_STARTER_LIMITS, PROJECT_SOURCE_LIMITS, PyPiLockDependencyResolver, RuntimeDriverRegistry, TRUSTED_JUDGE_RUNTIME_PROFILES, TRUSTED_JUDGE_WASIP1_IMPORTS, TRUSTED_JUDGE_WASM_MAX_BYTES, WASM_OJ_CONTAINER_PROTOCOL_VERSION, WASM_OJ_JUDGE_DATA_SCHEMA, WASM_OJ_JUDGE_PACKAGE_MAGIC, WASM_OJ_JUDGE_PACKAGE_MAX_BYTES, WASM_OJ_JUDGE_PACKAGE_SCHEMA, WASM_OJ_LIBCXX_PCH_HEADER, WASM_OJ_RELEASE_MANIFEST_SCHEMA, WASM_OJ_RUNTIME_COMPONENTS, WASM_OJ_RUNTIME_IDENTITY_SHA256, WEIGHTED_METER_MODEL, assertCompilerCacheKey, assertJudgeDataCostProfile, assertJudgeDataMatchesPracticePublic, assertJudgeGuestFilePath, assertProblemCostProfile, assertValidBuildArtifact, assertValidDependencyBuildBundle, assertValidDependencyLock, assertValidProject, assertValidReplayBundle, browserToolchainAssetBaseUrl, browserToolchainAssetUrl, canonicalJsonBytes, compareConformanceSnapshots, contestPublicProjectionBytes, costProfileId, createContestPublicProjection, createDefaultCostBaselineRegistry, createDefaultDependencyBuildAdapters, createDefaultDependencyManager, createDefaultDependencyResolvers, createDefaultRuntimeDrivers, createDependencyBuildBundle, createDependencyLock, createEngine, createExtendedCostBaselineRegistry, createJudgeExecutor, createReleaseManifest, createReplayBundle, createRuntimeBundleManifest, createSdkProject, decodeJudgePackageForExecution, decodeLibcxxPchManifest, decodeReplayBundle, dependencyFileTreeSha256, dependencyLockSha256, dependencyManifestSha256, deriveContestPublic, deriveJudgeData, derivePracticePublic, deterministicTranscript, encodeJudgePackage, encodeReplayBundle, fileMatcher, floatMatcher, goModuleZipHash, isCostProfileFor, isToolchainLibcxxPchHeader, judgePackageSemanticDigest, judgeTranscript, normalizeDependencyNetworkAccess, normalizeDependencyNetworkScope, normalizeExecutionMetrics, normalizeOutput, parseCanonicalJsonBytes, parseJudgeAllowedProfiles, parseJudgeData, parseJudgePackageManifest, parseManagedCollectionContract, parseManagedCollectionSource, parseManagedCollectionV2, parseManagedCollectionValueV2, parseProblemBundle, parseProblemCollectionIndex, parseReleaseManifest, parseStandaloneProblemBundle, prepareArtifactInteraction, prepareArtifactRun, prepareTrustedJudgeRun, problemCollectionRevision, readJudgePackageManifest, releaseManifestBytes, releaseManifestSha256, replayBundle, replayBundleSha256, resolveArtifactCostBudget, resolveCostBudget, resolveDeterminism, resolveResourcePolicy, runConformanceHost, runConformanceMatrix, runtimeIdentityBytes, scoreJudgeDataResults, scoreProblemResults, setMatcher, sha256Matcher, snapshotBrowserToolchainSources, summarizeProblemPolicies, textMatcher, tokenMatcher, toolchainAssetSource, toolchainCacheIdentity, toolchainProfileSource, trustedJudgeSpec, unavailableExecutionMetrics, validateBrowserToolchainSources, validateJudgePackage, validateJudgeSpec, validateServerToolchainSources, validateToolchainDescriptors, validateTrustedJudgeWasm, verifyDependencyBuildBundle, verifyProblemBundleBytes, verifyProblemCollectionRevision, verifyReleaseManifestBytes, verifyRuntimeIdentity, wasmCheckerMatcher };
-export type { ArtifactBuildExpectation, ArtifactDigest, ArtifactStore, BatchJudgeCaseSpec, CanonicalJsonValue, CompileInput, CompileOptions, Compiler, CompilerRegistration, ConformanceCase, ConformanceHost, ConformanceMismatch, ConformanceOptions, ConformanceReport, ConformanceRunExpectation, ConformanceSample, ConformanceSnapshot, ContestPublicProjection, CostBudget, CppDependencyLockSource, DecodedJudgePackageForExecution, DependencyBuildAdapter, DependencyBuildBundle, DependencyCache, DependencyConsentStorage, DependencyEcosystem, DependencyFetch, DependencyLock, DependencyManifest, DependencyNetworkAccess, DependencyNetworkAuthorizer, DependencyNetworkConsentPrompt, DependencyNetworkScope, DependencyOfflineBundle, DependencyRequirement, DependencyResolutionContext, DependencyResolver, DependencyResolverOptions, DependencySourceFile, DeterministicTranscript, EncodedJudgePackage, EngineOptions, ExecuteResult, InteractiveExecuteResult, InteractiveJudgeCaseSpec, InteractiveOptions, InteractiveProgramOptions, JudgeAllowedProfile, JudgeAllowedProfiles, JudgeCaseResult, JudgeCaseSpec, JudgeCaseVerdict, JudgeData, JudgeDataCase, JudgeEngineOptions, JudgeExecutionAdapter, JudgeExecutor, JudgeFileInputSpec, JudgeInputProvider, JudgeInputSpec, JudgeMatchResult, JudgeMatcher, JudgeMatcherContext, JudgeMatcherSpec, JudgePackageAllowedProfile, JudgePackageAssetInput, JudgePackageAssetReference, JudgePackageBlobReference, JudgePackageByteSource, JudgePackageInput, JudgePackageInputJudge, JudgePackageManifest, JudgePackageManifestJudge, JudgePolicy, JudgeProblem, JudgeProgramSpec, JudgeProjectResult, JudgeResolvedInput, JudgeResult, JudgeRunOptions, JudgeSpec, JudgeStarterTemplate, JudgeStarterTemplates, LibcxxPchAsset, LibcxxPchManifest, LibcxxPchProfile, LockedDependencyPackage, ManagedCollectionSource, ManagedCollectionSourceProblem, ManagedCollectionV2, ManagedProblemPublication, ManagedRepositoryObject, ManagedSourceArtifact, ManagedSourceAsset, ManagedSourceJudge, ManagedSourceObject, MaterializedDependencyPackage, Operation, OperationEvent, OperationEventPayload, OperationKind, OperationState, OutputNormalization, PackageFileSystemRequest, PolicyPerformanceAggregate, PrecompileOutcome, PrecompileStatus, PreparedRunRequest, ProblemBundleDescriptor, ProblemCollectionEntry, ProblemCollectionIndex, ProblemScore, RawExecutionMetrics, ReleaseManifest, ReplayBundle, ReplayBundleInput, ReplayDecodeOptions, ReplayHost, ReplayJudgeCaseTranscript, ReplayJudgeOperation, ReplayJudgeTranscript, ReplayOperation, ReplayOptions, ReplayResult, ReplayRunOperation, ResolveDependencyOptions, ResolvedDependencyGraph, RunOptions, Runner, RuntimeDriver, RuntimeResolver, ScoredProblemCase, SubmissionOperation, SubmissionPolicySummary, SubmissionRequest, TrustedJudgeAsset, TrustedJudgeExecutable, TrustedJudgeProgram, TrustedJudgeRuntimeProfile, TrustedJudgeWasmInfo, TrustedJudgeWasmValidationOptions, ValidateJudgePackageOptions, ValidatedJudgePackage };
+export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, BrowserDependencyNetworkConsent, CONTEST_PUBLIC_PROJECTION_SCHEMA, CPP_STDLIB_CONFORMANCE_CASE, CargoLockDependencyResolver, CompilerRegistry, CostBaselineRegistry, CppLockDependencyResolver, DEFAULT_CONFORMANCE_CASES, DEFAULT_DETERMINISM, DEFAULT_RESOURCE_POLICY, DEPENDENCY_BUILD_LIMITS, DependencyManager, DependencyNetworkError, Engine, FULL_CONFORMANCE_CASES, GoLockDependencyResolver, JudgeEngine, MemoryDependencyCache, NpmLockDependencyResolver, PROBLEM_STARTER_LIMITS, PROJECT_SOURCE_LIMITS, PyPiLockDependencyResolver, REPOSITORY_AUTHORING_JUDGES_SCHEMA, RuntimeDriverRegistry, TRUSTED_JUDGE_RUNTIME_PROFILES, TRUSTED_JUDGE_WASIP1_IMPORTS, TRUSTED_JUDGE_WASM_MAX_BYTES, WASM_OJ_JUDGE_DATA_SCHEMA, WASM_OJ_JUDGE_PACKAGE_MAGIC, WASM_OJ_JUDGE_PACKAGE_MAX_BYTES, WASM_OJ_JUDGE_PACKAGE_SCHEMA, WASM_OJ_LIBCXX_PCH_HEADER, WASM_OJ_RUNTIME_COMPONENTS, WASM_OJ_RUNTIME_IDENTITY_SHA256, WEIGHTED_METER_MODEL, assertCompilerCacheKey, assertJudgeDataCostProfile, assertJudgeDataMatchesPracticePublic, assertJudgeGuestFilePath, assertProblemCostProfile, assertValidBuildArtifact, assertValidDependencyBuildBundle, assertValidDependencyLock, assertValidProject, assertValidReplayBundle, browserToolchainAssetBaseUrl, browserToolchainAssetUrl, canonicalJsonBytes, compareConformanceSnapshots, contestPublicProjectionBytes, costProfileId, createContestPublicProjection, createDefaultCostBaselineRegistry, createDefaultDependencyBuildAdapters, createDefaultDependencyManager, createDefaultDependencyResolvers, createDefaultRuntimeDrivers, createDependencyBuildBundle, createDependencyLock, createEngine, createExtendedCostBaselineRegistry, createJudgeExecutor, createReplayBundle, createRuntimeBundleManifest, createSdkProject, decodeJudgePackageForExecution, decodeLibcxxPchManifest, decodeReplayBundle, dependencyFileTreeSha256, dependencyLockSha256, dependencyManifestSha256, deriveContestPublic, deriveJudgeData, derivePracticePublic, deterministicTranscript, encodeJudgePackage, encodeReplayBundle, fileMatcher, floatMatcher, goModuleZipHash, isCostProfileFor, isToolchainLibcxxPchHeader, judgePackageSemanticDigest, judgeTranscript, normalizeDependencyNetworkAccess, normalizeDependencyNetworkScope, normalizeExecutionMetrics, normalizeOutput, parseCanonicalJsonBytes, parseJudgeAllowedProfiles, parseJudgeData, parseJudgePackageManifest, parseProblemBundle, parseProblemCollectionIndex, parseRepositoryAuthoringJudges, parseStandaloneProblemBundle, prepareArtifactInteraction, prepareArtifactRun, prepareTrustedJudgeRun, problemCollectionRevision, readJudgePackageManifest, replayBundle, replayBundleSha256, resolveArtifactCostBudget, resolveCostBudget, resolveDeterminism, resolveResourcePolicy, runConformanceHost, runConformanceMatrix, runtimeIdentityBytes, scoreJudgeDataResults, scoreProblemResults, setMatcher, sha256Matcher, snapshotBrowserToolchainSources, summarizeProblemPolicies, textMatcher, tokenMatcher, toolchainAssetSource, toolchainCacheIdentity, toolchainProfileSource, trustedJudgeSpec, unavailableExecutionMetrics, validateBrowserToolchainSources, validateJudgePackage, validateJudgeSpec, validateServerToolchainSources, validateToolchainDescriptors, validateTrustedJudgeWasm, verifyDependencyBuildBundle, verifyProblemBundleBytes, verifyProblemCollectionRevision, verifyRuntimeIdentity, wasmCheckerMatcher };
+export type { ArtifactBuildExpectation, ArtifactStore, BatchJudgeCaseSpec, CanonicalJsonValue, CompileInput, CompileOptions, Compiler, CompilerRegistration, ConformanceCase, ConformanceHost, ConformanceMismatch, ConformanceOptions, ConformanceReport, ConformanceRunExpectation, ConformanceSample, ConformanceSnapshot, ContestPublicProjection, CostBudget, CppDependencyLockSource, DecodedJudgePackageForExecution, DependencyBuildAdapter, DependencyBuildBundle, DependencyCache, DependencyConsentStorage, DependencyEcosystem, DependencyFetch, DependencyLock, DependencyManifest, DependencyNetworkAccess, DependencyNetworkAuthorizer, DependencyNetworkConsentPrompt, DependencyNetworkScope, DependencyOfflineBundle, DependencyRequirement, DependencyResolutionContext, DependencyResolver, DependencyResolverOptions, DependencySourceFile, DeterministicTranscript, EncodedJudgePackage, EngineOptions, ExecuteResult, InteractiveExecuteResult, InteractiveJudgeCaseSpec, InteractiveOptions, InteractiveProgramOptions, JudgeAllowedProfile, JudgeAllowedProfiles, JudgeCaseResult, JudgeCaseSpec, JudgeCaseVerdict, JudgeData, JudgeDataCase, JudgeEngineOptions, JudgeExecutionAdapter, JudgeExecutor, JudgeFileInputSpec, JudgeInputProvider, JudgeInputSpec, JudgeMatchResult, JudgeMatcher, JudgeMatcherContext, JudgeMatcherSpec, JudgePackageAllowedProfile, JudgePackageAssetInput, JudgePackageAssetReference, JudgePackageBlobReference, JudgePackageByteSource, JudgePackageInput, JudgePackageInputJudge, JudgePackageManifest, JudgePackageManifestJudge, JudgePolicy, JudgeProblem, JudgeProgramSpec, JudgeProjectResult, JudgeResolvedInput, JudgeResult, JudgeRunOptions, JudgeSpec, JudgeStarterTemplate, JudgeStarterTemplates, LibcxxPchAsset, LibcxxPchManifest, LibcxxPchProfile, LockedDependencyPackage, MaterializedDependencyPackage, Operation, OperationEvent, OperationEventPayload, OperationKind, OperationState, OutputNormalization, PackageFileSystemRequest, PolicyPerformanceAggregate, PrecompileOutcome, PrecompileStatus, PreparedRunRequest, ProblemBundleDescriptor, ProblemCollectionEntry, ProblemCollectionIndex, ProblemScore, RawExecutionMetrics, ReplayBundle, ReplayBundleInput, ReplayDecodeOptions, ReplayHost, ReplayJudgeCaseTranscript, ReplayJudgeOperation, ReplayJudgeTranscript, ReplayOperation, ReplayOptions, ReplayResult, ReplayRunOperation, RepositoryAuthoringJudgeProblem, RepositoryAuthoringJudges, RepositorySourceArtifact, RepositorySourceAsset, RepositorySourceJudge, RepositorySourceObject, ResolveDependencyOptions, ResolvedDependencyGraph, RunOptions, Runner, RuntimeDriver, RuntimeResolver, ScoredProblemCase, SubmissionOperation, SubmissionPolicySummary, SubmissionRequest, TrustedJudgeAsset, TrustedJudgeExecutable, TrustedJudgeProgram, TrustedJudgeRuntimeProfile, TrustedJudgeWasmInfo, TrustedJudgeWasmValidationOptions, ValidateJudgePackageOptions, ValidatedJudgePackage };

package/dist/index.js

@@ -351,8 +351,8 @@ async function sha256Hex$1(value) {
 //#region src/core/runtime-identity.ts
 /** Executable runtime components covered by deterministic cost calibration. */
 var WASM_OJ_RUNTIME_COMPONENTS = Object.freeze({
-	runtimeCoreWasmSha256: "92500f3a2e65fe6979e893179d8000e12d66822c160eeb779b0d4fe0a6b55603",
-	runtimeSourceRootSha256: "3ef42cb2c70e7013e4a6f9d4d7457a7071101795fbd3753efcd20c1ac338ebd5",
+	runtimeCoreWasmSha256: "e4c7fca566ff5ba66931e0cf11cacbf37610d35c36d5f3ee97d719468a2f6466",
+	runtimeSourceRootSha256: "0140ecc6ed5060eae465e73db6822bcde32295734517de84929a537e3c45e663",
 	wasmerNativeVersion: "7.2.1",
 	wasmerSdkVersion: "0.10.0",
 	wasmerSdkWasmSha256: "49a6646209f5ab5e7c737eac33407d87d9a9959ac83e5ecaaab9261b2323589e",
@@ -363,13 +363,13 @@ var WASM_OJ_RUNTIME_COMPONENTS = Object.freeze({
 * Release verification independently checks the component bytes before this
 * identity is admitted into a calibrated release.
 */
-var WASM_OJ_RUNTIME_IDENTITY_SHA256 = "24c0bcff9820fbfd1fd4db1c57e2a866b83041409dd22b5b725688739bd3e223";
+var WASM_OJ_RUNTIME_IDENTITY_SHA256 = "59414bf4fa5191d0942c0e190c69d32f3a2251461b8eb41aaba32598baab1d5f";
 /** Exact canonical serialization hashed by `WASM_OJ_RUNTIME_IDENTITY_SHA256`. */
 function runtimeIdentityBytes() {
 	return canonicalJsonBytes(WASM_OJ_RUNTIME_COMPONENTS);
 }
 async function verifyRuntimeIdentity() {
-	if (await sha256Hex$1(runtimeIdentityBytes()) !== "24c0bcff9820fbfd1fd4db1c57e2a866b83041409dd22b5b725688739bd3e223") throw new Error("WASM-OJ runtime identity declaration does not match its digest.");
+	if (await sha256Hex$1(runtimeIdentityBytes()) !== "59414bf4fa5191d0942c0e190c69d32f3a2251461b8eb41aaba32598baab1d5f") throw new Error("WASM-OJ runtime identity declaration does not match its digest.");
 }
 //#endregion
 //#region src/core/cost-profile.ts
@@ -511,249 +511,6 @@ function assertNonNegativeMetric(value, label) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${label} must be a non-negative safe integer.`);
 }
 //#endregion
-//#region src/release-manifest.ts
-var SHA256$6 = /^[0-9a-f]{64}$/;
-var OCI_DIGEST = /^sha256:[0-9a-f]{64}$/;
-var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-var SEMVER = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-var VERSION = /^[0-9A-Za-z][0-9A-Za-z._+-]{0,127}$/;
-var IDENTITY = /^[A-Za-z0-9][A-Za-z0-9._:/@+-]{0,511}$/;
-var WASM_OJ_RELEASE_MANIFEST_SCHEMA = WASM_OJ_SCHEMAS$1.releaseManifest;
-var WASM_OJ_CONTAINER_PROTOCOL_VERSION = "wasm-oj-container-v2";
-function record$5(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
-	return value;
-}
-function exact$4(value, required, optional, label) {
-	const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
-	if (required.some((key) => !Object.hasOwn(value, key)) || Object.keys(value).some((key) => !allowed.has(key))) throw new TypeError(`${label} has an invalid shape.`);
-}
-function digest$1(value, label) {
-	if (typeof value !== "string" || !SHA256$6.test(value)) throw new TypeError(`${label} must be a lowercase SHA-256 digest.`);
-	return value;
-}
-function version(value, label) {
-	if (typeof value !== "string" || !VERSION.test(value)) throw new TypeError(`${label} is invalid.`);
-	return value;
-}
-function artifact(value, label) {
-	const item = record$5(value, label);
-	exact$4(item, ["bytes", "sha256"], [], label);
-	if (!Number.isSafeInteger(item.bytes) || item.bytes < 1) throw new TypeError(`${label}.bytes must be a positive safe integer.`);
-	return {
-		bytes: item.bytes,
-		sha256: digest$1(item.sha256, `${label}.sha256`)
-	};
-}
-function timestamp(value) {
-	if (typeof value !== "string" || new Date(value).toISOString() !== value) throw new TypeError("createdAt must be a canonical ISO timestamp.");
-	return value;
-}
-function sourceRepository(value) {
-	if (typeof value !== "string") throw new TypeError("source.repository must be a GitHub HTTPS URL.");
-	let url;
-	try {
-		url = new URL(value);
-	} catch (error) {
-		throw new TypeError("source.repository must be a GitHub HTTPS URL.", { cause: error });
-	}
-	if (url.protocol !== "https:" || url.hostname !== "github.com" || url.username || url.password || url.search || url.hash || url.pathname.split("/").filter(Boolean).length !== 2) throw new TypeError("source.repository must identify one credential-free GitHub repository.");
-	return url.toString().replace(/\/$/, "");
-}
-function parseReleaseManifest(value) {
-	const manifest = record$5(value, "release manifest");
-	exact$4(manifest, [
-		"artifacts",
-		"build",
-		"cost",
-		"createdAt",
-		"evidence",
-		"wasmOjContract",
-		"migrations",
-		"provenance",
-		"releaseId",
-		"runtime",
-		"schema",
-		"source",
-		"toolchains",
-		"version"
-	], [], "release manifest");
-	if (manifest.schema !== WASM_OJ_RELEASE_MANIFEST_SCHEMA) throw new TypeError("Release manifest schema is unsupported.");
-	if (manifest.wasmOjContract !== WASM_OJ_CONTRACT_VERSION$1) throw new TypeError("Release manifest uses another WASM-OJ contract.");
-	if (typeof manifest.releaseId !== "string" || !UUID.test(manifest.releaseId)) throw new TypeError("releaseId must be a UUID.");
-	if (typeof manifest.version !== "string" || !SEMVER.test(manifest.version)) throw new TypeError("version must be semantic versioning.");
-	const source = record$5(manifest.source, "source");
-	exact$4(source, [
-		"commit",
-		"repository",
-		"sourceTreeSha256"
-	], ["tag"], "source");
-	if (typeof source.commit !== "string" || !/^[0-9a-f]{40}$/.test(source.commit)) throw new TypeError("source.commit must be an exact Git commit SHA.");
-	if (source.tag !== void 0 && (typeof source.tag !== "string" || !VERSION.test(source.tag))) throw new TypeError("source.tag is invalid.");
-	const build = record$5(manifest.build, "build");
-	exact$4(build, [
-		"auditSha256",
-		"licensesSha256",
-		"lockSha256",
-		"nodeVersion",
-		"pnpmVersion",
-		"rustVersion",
-		"sbomSha256"
-	], [], "build");
-	const artifacts = record$5(manifest.artifacts, "artifacts");
-	exact$4(artifacts, [
-		"containerImage",
-		"npmPackage",
-		"staticAssets",
-		"workerBundle"
-	], [], "artifacts");
-	const container = record$5(artifacts.containerImage, "artifacts.containerImage");
-	exact$4(container, [
-		"baseImages",
-		"digest",
-		"dockerfileSha256",
-		"identitySha256",
-		"platform",
-		"registry"
-	], [], "artifacts.containerImage");
-	if (typeof container.registry !== "string" || !IDENTITY.test(container.registry)) throw new TypeError("Container registry identity is invalid.");
-	if (typeof container.digest !== "string" || !OCI_DIGEST.test(container.digest) || container.platform !== "linux/amd64") throw new TypeError("Container image identity is invalid.");
-	if (!Array.isArray(container.baseImages) || container.baseImages.length !== 3) throw new TypeError("Container base image inventory is invalid.");
-	const expectedStages = [
-		"node-build",
-		"rust-build",
-		"judge"
-	];
-	const baseImages = container.baseImages.map((value, index) => {
-		const base = record$5(value, `container base image ${index}`);
-		exact$4(base, [
-			"digest",
-			"image",
-			"stage"
-		], [], `container base image ${index}`);
-		if (base.stage !== expectedStages[index] || typeof base.image !== "string" || !IDENTITY.test(base.image) || typeof base.digest !== "string" || !OCI_DIGEST.test(base.digest)) throw new TypeError("Container base image inventory is invalid.");
-		return {
-			stage: base.stage,
-			image: base.image,
-			digest: base.digest
-		};
-	});
-	const runtime = record$5(manifest.runtime, "runtime");
-	exact$4(runtime, [
-		"compilerSha256",
-		"executionRootSha256",
-		"protocolVersion",
-		"rootSha256",
-		"runnerSha256",
-		"runtimeCoreSha256",
-		"runtimeIdentitySha256",
-		"wasmerSha256",
-		"wasmerVersion"
-	], [], "runtime");
-	if (runtime.protocolVersion !== "wasm-oj-container-v2") throw new TypeError("Container protocol is unsupported.");
-	if (runtime.runtimeIdentitySha256 !== "24c0bcff9820fbfd1fd4db1c57e2a866b83041409dd22b5b725688739bd3e223") throw new TypeError("Release runtime identity does not match this WASM-OJ build.");
-	const toolchains = record$5(manifest.toolchains, "toolchains");
-	exact$4(toolchains, ["manifestSha256", "rootSha256"], [], "toolchains");
-	const cost = record$5(manifest.cost, "cost");
-	exact$4(cost, [
-		"baselineSha256",
-		"model",
-		"profileRootSha256"
-	], [], "cost");
-	if (cost.model !== "weighted") throw new TypeError("Release cost model is unsupported.");
-	const evidence = record$5(manifest.evidence, "evidence");
-	exact$4(evidence, [
-		"conformanceSha256",
-		"costCalibrationSha256",
-		"testsSha256"
-	], [], "evidence");
-	const migrations = record$5(manifest.migrations, "migrations");
-	exact$4(migrations, ["databaseSha256"], [], "migrations");
-	const provenance = record$5(manifest.provenance, "provenance");
-	exact$4(provenance, ["issuer", "subject"], [], "provenance");
-	if (typeof provenance.issuer !== "string" || !IDENTITY.test(provenance.issuer) || typeof provenance.subject !== "string" || !IDENTITY.test(provenance.subject)) throw new TypeError("Release provenance identity is invalid.");
-	return {
-		schema: WASM_OJ_RELEASE_MANIFEST_SCHEMA,
-		releaseId: manifest.releaseId,
-		version: manifest.version,
-		wasmOjContract: WASM_OJ_CONTRACT_VERSION$1,
-		createdAt: timestamp(manifest.createdAt),
-		source: {
-			repository: sourceRepository(source.repository),
-			commit: source.commit,
-			sourceTreeSha256: digest$1(source.sourceTreeSha256, "source.sourceTreeSha256"),
-			...source.tag === void 0 ? {} : { tag: source.tag }
-		},
-		build: {
-			nodeVersion: version(build.nodeVersion, "build.nodeVersion"),
-			pnpmVersion: version(build.pnpmVersion, "build.pnpmVersion"),
-			rustVersion: version(build.rustVersion, "build.rustVersion"),
-			lockSha256: digest$1(build.lockSha256, "build.lockSha256"),
-			sbomSha256: digest$1(build.sbomSha256, "build.sbomSha256"),
-			licensesSha256: digest$1(build.licensesSha256, "build.licensesSha256"),
-			auditSha256: digest$1(build.auditSha256, "build.auditSha256")
-		},
-		artifacts: {
-			npmPackage: artifact(artifacts.npmPackage, "artifacts.npmPackage"),
-			workerBundle: artifact(artifacts.workerBundle, "artifacts.workerBundle"),
-			staticAssets: artifact(artifacts.staticAssets, "artifacts.staticAssets"),
-			containerImage: {
-				registry: container.registry,
-				digest: container.digest,
-				identitySha256: digest$1(container.identitySha256, "artifacts.containerImage.identitySha256"),
-				platform: "linux/amd64",
-				dockerfileSha256: digest$1(container.dockerfileSha256, "artifacts.containerImage.dockerfileSha256"),
-				baseImages
-			}
-		},
-		runtime: {
-			protocolVersion: WASM_OJ_CONTAINER_PROTOCOL_VERSION,
-			executionRootSha256: digest$1(runtime.executionRootSha256, "runtime.executionRootSha256"),
-			rootSha256: digest$1(runtime.rootSha256, "runtime.rootSha256"),
-			runtimeIdentitySha256: WASM_OJ_RUNTIME_IDENTITY_SHA256,
-			runtimeCoreSha256: digest$1(runtime.runtimeCoreSha256, "runtime.runtimeCoreSha256"),
-			wasmerVersion: version(runtime.wasmerVersion, "runtime.wasmerVersion"),
-			wasmerSha256: digest$1(runtime.wasmerSha256, "runtime.wasmerSha256"),
-			compilerSha256: digest$1(runtime.compilerSha256, "runtime.compilerSha256"),
-			runnerSha256: digest$1(runtime.runnerSha256, "runtime.runnerSha256")
-		},
-		toolchains: {
-			rootSha256: digest$1(toolchains.rootSha256, "toolchains.rootSha256"),
-			manifestSha256: digest$1(toolchains.manifestSha256, "toolchains.manifestSha256")
-		},
-		cost: {
-			model: WEIGHTED_METER_MODEL,
-			profileRootSha256: digest$1(cost.profileRootSha256, "cost.profileRootSha256"),
-			baselineSha256: digest$1(cost.baselineSha256, "cost.baselineSha256")
-		},
-		evidence: {
-			conformanceSha256: digest$1(evidence.conformanceSha256, "evidence.conformanceSha256"),
-			testsSha256: digest$1(evidence.testsSha256, "evidence.testsSha256"),
-			costCalibrationSha256: digest$1(evidence.costCalibrationSha256, "evidence.costCalibrationSha256")
-		},
-		migrations: { databaseSha256: digest$1(migrations.databaseSha256, "migrations.databaseSha256") },
-		provenance: {
-			issuer: provenance.issuer,
-			subject: provenance.subject
-		}
-	};
-}
-function createReleaseManifest(value) {
-	return parseReleaseManifest(value);
-}
-function releaseManifestBytes(value) {
-	return canonicalJsonBytes(parseReleaseManifest(value));
-}
-async function releaseManifestSha256(value) {
-	return sha256Hex$1(releaseManifestBytes(value));
-}
-async function verifyReleaseManifestBytes(bytes, expectedSha256) {
-	if (expectedSha256 !== void 0) {
-		if (digest$1(expectedSha256, "expected release manifest digest") !== await sha256Hex$1(bytes)) throw new TypeError("Release manifest bytes do not match the expected digest.");
-	}
-	return parseReleaseManifest(parseCanonicalJsonBytes(bytes, "release manifest"));
-}
-//#endregion
 //#region src/core/project-files.ts
 var PROJECT_SOURCE_LIMITS = Object.freeze({
 	files: 256,
@@ -807,7 +564,7 @@ function canonicalFileEntries(files) {
 //#endregion
 //#region src/core/dependencies.ts
 var MIB = 1048576;
-var SHA256$5 = /^[0-9a-f]{64}$/;
+var SHA256$3 = /^[0-9a-f]{64}$/;
 /** Contract-level admission limits shared by dependency hosts and compilers. */
 var DEPENDENCY_RESOLUTION_LIMITS = Object.freeze({
 	requirements: 128,
@@ -999,7 +756,7 @@ function assertSortedUnique(values, label) {
 	for (let index = 1; index < values.length; index += 1) if (values[index - 1] >= values[index]) throw new Error(`${label} must be sorted and unique.`);
 }
 function requireSha256$2(value, label) {
-	if (typeof value !== "string" || !SHA256$5.test(value)) throw new Error(`${label} SHA-256 must be lowercase hexadecimal.`);
+	if (typeof value !== "string" || !SHA256$3.test(value)) throw new Error(`${label} SHA-256 must be lowercase hexadecimal.`);
 }
 function isRecord$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -5341,10 +5098,10 @@ function quickJsBundle(artifact, stdin, config) {
 ${quickJsDeterminismPrelude(config.determinism)}
 const __modules = ${JSON.stringify(modules)};
 const __packageManifests = ${JSON.stringify(packageManifests)};
-const __input = ${JSON.stringify(stdin)};
+let __input = ${JSON.stringify(stdin)};
 const __cache = Object.create(null);
 const __std = {
-  in: { readAsString: () => __input },
+  in: { readAsString: () => { const result = __input; __input = ""; return result; } },
   out: { puts: (value) => __wasm_oj_write_stdout(String(value)) },
   err: { puts: (value) => __wasm_oj_write_stderr(String(value)) },
 };
@@ -6079,124 +5836,12 @@ function observedJudgeDataMetrics(data, language, result) {
 	return observed;
 }
 //#endregion
-//#region src/online-judge/compile-profiles.ts
-function record$4(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$4(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$1(language)) throw new TypeError(`${label} language '${language}' is unsupported.`);
-		const profile = record$4(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/managed-collection.ts
-var MANAGED_COLLECTION_SCHEMA = "wasm-oj-platform/managed-collection/v2";
-var SHA256$4 = /^[0-9a-f]{64}$/;
-var SLUG$1 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var PATH$1 = /^(?!\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*\\)(?!.*\/$)[^\u0000]+$/;
-var MAX_MANAGED_COLLECTION_BYTES = 2097152;
-var MAX_PROJECTION_BYTES = 33554432;
-function record$3(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object.`);
-	return value;
-}
-function exact$3(value, expected, label) {
-	const actual = Object.keys(value).sort();
-	const wanted = [...expected].sort();
-	if (JSON.stringify(actual) !== JSON.stringify(wanted)) throw new TypeError(`${label} must contain exactly: ${wanted.join(", ")}.`);
-}
-function repositoryObject(value, label, maximum) {
-	const object = record$3(value, label);
-	exact$3(object, [
-		"bytes",
-		"repositoryPath",
-		"sha256"
-	], label);
-	if (typeof object.repositoryPath !== "string" || object.repositoryPath.length < 1 || object.repositoryPath.length > 512 || !PATH$1.test(object.repositoryPath)) throw new TypeError(`${label}.repositoryPath must be a normalized relative POSIX path.`);
-	if (!Number.isSafeInteger(object.bytes) || object.bytes < 1 || object.bytes > maximum) throw new TypeError(`${label}.bytes is outside its publication limit.`);
-	if (typeof object.sha256 !== "string" || !SHA256$4.test(object.sha256)) throw new TypeError(`${label}.sha256 must be a lowercase SHA-256 digest.`);
-	return {
-		repositoryPath: object.repositoryPath,
-		bytes: object.bytes,
-		sha256: object.sha256
-	};
-}
-/** Parse the value form used by the authoring CLI after JSON decoding. */
-function parseManagedCollectionValueV2(value) {
-	const collection = record$3(value, "managed collection");
-	exact$3(collection, [
-		"collectionRevision",
-		"problems",
-		"schema"
-	], "managed collection");
-	if (collection.schema !== "wasm-oj-platform/managed-collection/v2") throw new TypeError(`Managed collection schema must be '${MANAGED_COLLECTION_SCHEMA}'.`);
-	if (typeof collection.collectionRevision !== "string" || !SHA256$4.test(collection.collectionRevision)) throw new TypeError("Managed collection revision must be a lowercase SHA-256 digest.");
-	if (!Array.isArray(collection.problems) || collection.problems.length < 1 || collection.problems.length > 1e3) throw new TypeError("Managed collection must contain between 1 and 1000 problems.");
-	const slugs = /* @__PURE__ */ new Set();
-	const paths = /* @__PURE__ */ new Set();
-	const problems = collection.problems.map((candidate, index) => {
-		const problem = record$3(candidate, `managed problem ${index + 1}`);
-		exact$3(problem, [
-			"allowedProfiles",
-			"contestPublic",
-			"judgePackage",
-			"slug"
-		], `managed problem ${index + 1}`);
-		if (typeof problem.slug !== "string" || !SLUG$1.test(problem.slug) || slugs.has(problem.slug)) throw new TypeError(`Managed problem ${index + 1} has an invalid or duplicate slug.`);
-		slugs.add(problem.slug);
-		const allowedProfiles = parseJudgeAllowedProfiles(problem.allowedProfiles, `managed problem '${problem.slug}' allowedProfiles`);
-		const contestPublic = repositoryObject(problem.contestPublic, `managed problem '${problem.slug}' contestPublic`, 8388608);
-		const judgePackage = repositoryObject(problem.judgePackage, `managed problem '${problem.slug}' judgePackage`, MAX_PROJECTION_BYTES);
-		for (const path of [contestPublic.repositoryPath, judgePackage.repositoryPath]) {
-			if (paths.has(path)) throw new TypeError(`Managed publication path '${path}' is declared more than once.`);
-			paths.add(path);
-		}
-		return {
-			slug: problem.slug,
-			allowedProfiles,
-			contestPublic,
-			judgePackage
-		};
-	});
-	return {
-		schema: MANAGED_COLLECTION_SCHEMA,
-		collectionRevision: collection.collectionRevision,
-		problems
-	};
-}
-/**
-* Stable platform boundary for generated collection/managed.json bytes.
-* Published managed contracts must use WASM-OJ canonical JSON; author-only
-* managed-source documents are intentionally not accepted here.
-*/
-function parseManagedCollectionV2(bytes) {
-	if (!(bytes instanceof Uint8Array) || bytes.byteLength < 1 || bytes.byteLength > MAX_MANAGED_COLLECTION_BYTES) throw new TypeError("Managed collection bytes are outside the 2 MiB limit.");
-	return parseManagedCollectionValueV2(parseCanonicalJsonBytes(bytes, "managed collection"));
-}
-/** Same v2-only value parser retained as the environment-neutral library entry point. */
-var parseManagedCollectionContract = parseManagedCollectionValueV2;
-//#endregion
 //#region src/online-judge/contest-public.ts
 var CONTEST_PUBLIC_PROJECTION_SCHEMA = "wasm-oj-platform/contest-public-problem-projection/v1";
-var SHA256$3 = /^[0-9a-f]{64}$/;
 /**
-* The bundle referenced by collection/index.json is safe to fetch for every
-* practice visitor. Hidden cases and their expected answers exist only in the
-* immutable judge package built from the authoring source.
+* The repository practice bundle is safe to fetch for every practice visitor.
+* Hidden cases and their expected answers exist only in the immutable judge
+* package built from the authoring source.
 */
 function derivePracticePublic(authored) {
 	return {
@@ -6216,16 +5861,38 @@ function deriveContestPublic(practice) {
 		judgeCases: practice.judgeCases.filter((testCase) => testCase.kind === "sample").map((testCase) => structuredClone(testCase))
 	};
 }
-function createContestPublicProjection(practice, problemBundleSha256) {
-	if (typeof problemBundleSha256 !== "string" || !SHA256$3.test(problemBundleSha256)) throw new TypeError("Contest-public projection digest must be a lowercase SHA-256 digest.");
+function createContestPublicProjection(practice) {
 	return {
 		schema: CONTEST_PUBLIC_PROJECTION_SCHEMA,
-		problem: deriveContestPublic(practice),
-		digest: problemBundleSha256
+		problem: deriveContestPublic(practice)
 	};
 }
-function contestPublicProjectionBytes(practice, problemBundleSha256) {
-	return canonicalJsonBytes(createContestPublicProjection(practice, problemBundleSha256));
+function contestPublicProjectionBytes(practice) {
+	return canonicalJsonBytes(createContestPublicProjection(practice));
+}
+//#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$1(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/unicode-scalar.ts
@@ -6767,8 +6434,8 @@ async function validateJudgePackage(source, options = {}) {
 		}
 	}
 	const completed = await reader.finish();
-	if (options.expectedBytes !== void 0 && completed.bytes !== options.expectedBytes) throw new TypeError("Judge package byte length disagrees with its publication.");
-	if (options.expectedSha256 !== void 0 && completed.sha256 !== options.expectedSha256) throw new TypeError("Judge package digest disagrees with its publication.");
+	if (options.expectedBytes !== void 0 && completed.bytes !== options.expectedBytes) throw new TypeError("Judge package byte length disagrees with its descriptor.");
+	if (options.expectedSha256 !== void 0 && completed.sha256 !== options.expectedSha256) throw new TypeError("Judge package digest disagrees with its descriptor.");
 	if (!judgeData) throw new TypeError("Judge package is missing its judgeData blob.");
 	return {
 		manifest,
@@ -6988,8 +6655,8 @@ var IncrementalSha256 = class {
 	}
 };
 //#endregion
-//#region src/online-judge/managed-collection-source.ts
-var MANAGED_COLLECTION_SOURCE_SCHEMA = "wasm-oj-platform/managed-collection-source/v1";
+//#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 = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var PATH = /^(?!\/)(?!.*(?:^|\/)\.{1,2}(?:\/|$))(?!.*\/\/)(?!.*\\)(?!.*\/$)[^\u0000]+$/;
@@ -7001,9 +6668,7 @@ function record(value, label) {
 	return value;
 }
 function exact(value, keys, label) {
-	const actual = Object.keys(value).sort();
-	const expected = [...keys].sort();
-	if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new TypeError(`${label} has an invalid shape.`);
+	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(value, label);
@@ -7021,16 +6686,13 @@ function sourceObject(value, label, maximum) {
 		sha256: object.sha256
 	};
 }
-function profiles(value, slug) {
-	return parseJudgeAllowedProfiles(value, `managed source '${slug}' allowedProfiles`);
-}
 function judge(value, slug) {
-	const input = record(value, `managed source '${slug}' judge`);
+	const input = record(value, `repository authoring '${slug}' judge`);
 	if (input.kind === "text") {
-		exact(input, ["kind"], `managed source '${slug}' text judge`);
+		exact(input, ["kind"], `repository authoring '${slug}' text judge`);
 		return { kind: "text" };
 	}
-	if (input.kind !== "checker" && input.kind !== "interactive") throw new TypeError(`Managed source '${slug}' judge kind is unsupported.`);
+	if (input.kind !== "checker" && input.kind !== "interactive") throw new TypeError(`Repository authoring '${slug}' judge kind is unsupported.`);
 	exact(input, input.kind === "checker" ? [
 		"args",
 		"artifact",
@@ -7042,86 +6704,86 @@ function judge(value, slug) {
 		"assets",
 		"inputPath",
 		"kind"
-	], `managed source '${slug}' ${input.kind}`);
-	const artifactValue = record(input.artifact, `managed source '${slug}' ${input.kind} artifact`);
+	], `repository authoring '${slug}' ${input.kind}`);
+	const artifactValue = record(input.artifact, `repository authoring '${slug}' ${input.kind} artifact`);
 	exact(artifactValue, [
 		"bytes",
 		"path",
 		"runtimeProfile",
 		"sha256"
-	], `managed source '${slug}' ${input.kind} artifact`);
-	if (typeof artifactValue.runtimeProfile !== "string" || !TRUSTED_JUDGE_RUNTIME_PROFILES.has(artifactValue.runtimeProfile)) throw new TypeError(`Managed source '${slug}' ${input.kind} runtimeProfile is unsupported.`);
+	], `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
-		}, `managed source '${slug}' ${input.kind} artifact`, TRUSTED_JUDGE_WASM_MAX_BYTES),
+		}, `repository authoring '${slug}' ${input.kind} artifact`, TRUSTED_JUDGE_WASM_MAX_BYTES),
 		runtimeProfile: artifactValue.runtimeProfile
 	};
-	if (!artifact.path.endsWith(".wasm")) throw new TypeError(`Managed source '${slug}' ${input.kind} artifact path must end in '.wasm'.`);
-	if (!Array.isArray(input.assets) || input.assets.length > 256) throw new TypeError(`Managed source '${slug}' ${input.kind} assets are invalid.`);
+	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(candidate, `managed source '${slug}' ${input.kind} asset ${index}`);
+		const asset = record(candidate, `repository authoring '${slug}' ${input.kind} asset ${index}`);
 		exact(asset, [
 			"bytes",
 			"guestPath",
 			"path",
 			"sha256"
-		], `managed source '${slug}' ${input.kind} asset ${index}`);
-		if (typeof asset.guestPath !== "string" || !GUEST_PATH.test(asset.guestPath) || !asset.guestPath.startsWith(namespace)) throw new TypeError(`Managed source '${slug}' ${input.kind} asset ${index} guestPath must be inside '${namespace}'.`);
+		], `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
-			}, `managed source '${slug}' ${input.kind} asset ${index}`, MAX_ASSET_BYTES),
+			}, `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(`Managed source '${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(`Managed source '${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(`Managed source '${slug}' ${input.kind} args are invalid.`);
-	const judgeArgs = [...input.args];
+	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: judgeArgs
+		args
 	};
-	if (typeof input.inputPath !== "string" || !GUEST_PATH.test(input.inputPath) || !input.inputPath.startsWith("/interactor/input/")) throw new TypeError(`Managed source '${slug}' interactive inputPath must be inside '/interactor/input/'.`);
+	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: judgeArgs,
+		args,
 		inputPath: input.inputPath
 	};
 }
-/** Author-only parser. Platform publication parsers must never call this API. */
-function parseManagedCollectionSource(value) {
-	const source = record(value, "managed collection source");
-	exact(source, ["problems", "schema"], "managed collection source");
-	if (source.schema !== "wasm-oj-platform/managed-collection-source/v1") throw new TypeError(`Managed collection source schema must be '${MANAGED_COLLECTION_SOURCE_SCHEMA}'.`);
-	if (!Array.isArray(source.problems) || source.problems.length < 1 || source.problems.length > 1e3) throw new TypeError("Managed collection source must contain between 1 and 1000 problems.");
+/** Author-only input used by collection build; never accepted by the platform sync boundary. */
+function parseRepositoryAuthoringJudges(value) {
+	const source = record(value, "repository authoring judges");
+	exact(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: MANAGED_COLLECTION_SOURCE_SCHEMA,
+		schema: REPOSITORY_AUTHORING_JUDGES_SCHEMA,
 		problems: source.problems.map((candidate, index) => {
-			const problem = record(candidate, `managed source problem ${index + 1}`);
+			const problem = record(candidate, `repository authoring judge problem ${index + 1}`);
 			exact(problem, [
 				"allowedProfiles",
 				"judge",
 				"slug"
-			], `managed source problem ${index + 1}`);
-			if (typeof problem.slug !== "string" || !SLUG.test(problem.slug) || slugs.has(problem.slug)) throw new TypeError(`Managed source problem ${index + 1} has an invalid or duplicate slug.`);
+			], `repository authoring judge problem ${index + 1}`);
+			if (typeof problem.slug !== "string" || !SLUG.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: profiles(problem.allowedProfiles, problem.slug),
+				allowedProfiles: parseJudgeAllowedProfiles(problem.allowedProfiles, `repository authoring '${problem.slug}' allowedProfiles`),
 				judge: judge(problem.judge, problem.slug)
 			};
 		})
@@ -8394,6 +8056,129 @@ function requireSha256(value) {
 	if (!/^[0-9a-f]{64}$/.test(value)) throw new Error("Dependency integrity must be lowercase SHA-256 hexadecimal.");
 }
 //#endregion
+//#region src/conformance/stdio-cases.ts
+var programs = [
+	{
+		language: "c",
+		entry: "main.c",
+		source: "#include <stdio.h>\nint main(){int c;while((c=getchar())!=EOF)printf(\"%02x\",(unsigned)c);puts(\"\");return 0;}"
+	},
+	{
+		language: "cpp",
+		entry: "main.cpp",
+		source: "#include <iostream>\n#include <cstdio>\nint main(){char c;while(std::cin.get(c))printf(\"%02x\",(unsigned char)c);puts(\"\");}"
+	},
+	{
+		language: "python",
+		entry: "main.py",
+		source: "import sys\nprint(sys.stdin.buffer.read().hex())\n"
+	},
+	{
+		language: "rust",
+		entry: "main.rs",
+		source: "use std::io::{self,Read};fn main(){let mut b=Vec::new();io::stdin().read_to_end(&mut b).unwrap();for x in b{print!(\"{:02x}\",x);}println!();}"
+	},
+	{
+		language: "go",
+		entry: "main.go",
+		source: "package main\nimport(\"fmt\";\"io\";\"os\")\nfunc main(){b,_:=io.ReadAll(os.Stdin);fmt.Printf(\"%x\\n\",b)}"
+	},
+	{
+		language: "java",
+		entry: "Main.java",
+		source: "import java.io.*;public class Main{public static void main(String[]args)throws Exception{BufferedReader r=new BufferedReader(new InputStreamReader(System.in));String s;while((s=r.readLine())!=null)System.out.println(\"[\"+s+\"]\");System.out.println(\"EOF\");}}"
+	},
+	{
+		language: "javascript",
+		entry: "main.js",
+		source: "import * as std from \"std\";const s=std.in.readAsString();console.log(Array.from(unescape(encodeURIComponent(s)),c=>c.charCodeAt(0).toString(16).padStart(2,\"0\")).join(\"\"));if(std.in.readAsString()!==\"\")throw Error(\"Repeated stdin\");"
+	},
+	{
+		language: "typescript",
+		entry: "main.ts",
+		source: "import * as std from \"std\";const s=std.in.readAsString();console.log(Array.from(unescape(encodeURIComponent(s)),c=>c.charCodeAt(0).toString(16).padStart(2,\"0\")).join(\"\"));if(std.in.readAsString()!==\"\")throw Error(\"Repeated stdin\");"
+	}
+];
+var inputs = [
+	{
+		id: "empty",
+		stdin: ""
+	},
+	{
+		id: "lf",
+		stdin: "\n"
+	},
+	{
+		id: "one-byte",
+		stdin: "x"
+	},
+	{
+		id: "no-final-lf",
+		stdin: "abc"
+	},
+	{
+		id: "final-lf",
+		stdin: "abc\n"
+	},
+	{
+		id: "multiple-lf",
+		stdin: "abc\n\n"
+	},
+	{
+		id: "crlf",
+		stdin: "abc\r\nx\r\n"
+	},
+	{
+		id: "bare-cr",
+		stdin: "abc\rx"
+	},
+	{
+		id: "spaces",
+		stdin: "  abc 	\n x  "
+	},
+	{
+		id: "unicode",
+		stdin: "中文🙂\n終"
+	},
+	{
+		id: "bom",
+		stdin: "abc\n"
+	},
+	{
+		id: "nul",
+		stdin: "a\0b\n"
+	},
+	{
+		id: "long-line",
+		stdin: "x".repeat(8193)
+	},
+	{
+		id: "last-line",
+		stdin: "first\nlast"
+	}
+];
+var STDIO_CONFORMANCE_CASES = programs.flatMap((program) => inputs.map(({ id, stdin }) => {
+	const lines = stdin === "" ? [] : stdin.split(/\r\n|\r|\n/);
+	if (/[\r\n]$/.test(stdin)) lines.pop();
+	return {
+		id: `${program.language}-wasip1-stdio-${id}`,
+		label: `${program.language} / wasip1 / stdin ${id}`,
+		input: {
+			language: program.language,
+			target: "wasip1",
+			entry: program.entry,
+			files: { [program.entry]: program.source }
+		},
+		run: { stdin },
+		expect: {
+			code: 0,
+			stdout: program.language === "java" ? `${lines.map((line) => `[${line}]\n`).join("")}EOF\n` : `${Array.from(new TextEncoder().encode(stdin), (byte) => byte.toString(16).padStart(2, "0")).join("")}\n`,
+			stderr: "",
+			termination: "exited"
+		}
+	};
+}));
+//#endregion
 //#region src/conformance/cases.ts
 var DEFAULT_CONFORMANCE_CASES = deepFreeze([
 	{
@@ -8619,6 +8404,54 @@ var DEFAULT_CONFORMANCE_CASES = deepFreeze([
 			termination: "exited"
 		}
 	},
+	{
+		id: "python-wasip1-stdin-eof",
+		label: "Python / wasip1 / redirected input at EOF",
+		input: {
+			language: "python",
+			target: "wasip1",
+			entry: "src/main.py",
+			files: { "src/main.py": [
+				"import os, sys",
+				"assert not any(os.isatty(fd) for fd in range(3))",
+				"assert not any(stream.isatty() for stream in (sys.stdin, sys.stdout, sys.stderr))",
+				"assert input() == 'abc\\r'",
+				"assert input() == 'x'",
+				"assert input() == '終'",
+				"try:",
+				"    input()",
+				"except EOFError:",
+				"    print('OK')",
+				"else:",
+				"    raise AssertionError('Expected EOFError')",
+				""
+			].join("\n") }
+		},
+		run: { stdin: "abc\r\nx\n終" },
+		expect: {
+			code: 0,
+			stdout: "OK\n",
+			stderr: "",
+			termination: "exited"
+		}
+	},
+	{
+		id: "python-wasip1-stdin-bytes",
+		label: "Python / wasip1 / exact input bytes",
+		input: {
+			language: "python",
+			target: "wasip1",
+			entry: "src/main.py",
+			files: { "src/main.py": "import sys\nassert sys.stdin.buffer.read() == b'abc\\r\\nx'\nprint('OK')\n" }
+		},
+		run: { stdin: "abc\r\nx" },
+		expect: {
+			code: 0,
+			stdout: "OK\n",
+			stderr: "",
+			termination: "exited"
+		}
+	},
 	{
 		id: "javascript-wasip1",
 		label: "JavaScript / wasip1",
@@ -8968,11 +8801,15 @@ var CPP_STDLIB_CONFORMANCE_CASE = deepFreeze({
 		termination: "exited"
 	}
 });
-var FULL_CONFORMANCE_CASES = deepFreeze([...DEFAULT_CONFORMANCE_CASES, CPP_STDLIB_CONFORMANCE_CASE]);
+var FULL_CONFORMANCE_CASES = deepFreeze([
+	...DEFAULT_CONFORMANCE_CASES,
+	...STDIO_CONFORMANCE_CASES,
+	CPP_STDLIB_CONFORMANCE_CASE
+]);
 function deepFreeze(value) {
 	if (typeof value !== "object" || value === null || Object.isFrozen(value)) return value;
 	for (const child of Object.values(value)) deepFreeze(child);
 	return Object.freeze(value);
 }
 //#endregion
-export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, BrowserDependencyNetworkConsent, CONTEST_PUBLIC_PROJECTION_SCHEMA, CPP_STDLIB_CONFORMANCE_CASE, CargoLockDependencyResolver, CompilerRegistry, CostBaselineRegistry, CppLockDependencyResolver, DEFAULT_CONFORMANCE_CASES, DEFAULT_DETERMINISM, DEFAULT_RESOURCE_POLICY, DEPENDENCY_BUILD_LIMITS, DependencyManager, DependencyNetworkError, Engine, FULL_CONFORMANCE_CASES, GoLockDependencyResolver, JudgeEngine, LANGUAGES, MANAGED_COLLECTION_SCHEMA, MANAGED_COLLECTION_SOURCE_SCHEMA, MemoryDependencyCache, NpmLockDependencyResolver, PROBLEM_STARTER_LIMITS, PROJECT_SOURCE_LIMITS, PyPiLockDependencyResolver, RuntimeDriverRegistry, TRUSTED_JUDGE_RUNTIME_PROFILES, TRUSTED_JUDGE_WASIP1_IMPORTS, TRUSTED_JUDGE_WASM_MAX_BYTES, WASM_OJ_CONTAINER_PROTOCOL_VERSION, WASM_OJ_CONTRACT_ID, WASM_OJ_CONTRACT_VERSION, WASM_OJ_ERROR_CODES, WASM_OJ_ERROR_STAGES, WASM_OJ_JUDGE_DATA_SCHEMA, WASM_OJ_JUDGE_PACKAGE_MAGIC, WASM_OJ_JUDGE_PACKAGE_MAX_BYTES, WASM_OJ_JUDGE_PACKAGE_SCHEMA, WASM_OJ_LIBCXX_PCH_HEADER, WASM_OJ_RELEASE_MANIFEST_SCHEMA, WASM_OJ_RUNTIME_COMPONENTS, WASM_OJ_RUNTIME_IDENTITY_SHA256, WASM_OJ_SCHEMAS, WASM_OJ_STORAGE, WEIGHTED_METER_MODEL, WasmOjError, asWasmOjError, assertCompilerCacheKey, assertJudgeDataCostProfile, assertJudgeDataMatchesPracticePublic, assertJudgeGuestFilePath, assertLanguageIdentifier, assertProblemCostProfile, assertValidBuildArtifact, assertValidDependencyBuildBundle, assertValidDependencyLock, assertValidProject, assertValidReplayBundle, browserToolchainAssetBaseUrl, browserToolchainAssetUrl, canonicalJsonBytes, compareConformanceSnapshots, contestPublicProjectionBytes, costProfileId, createContestPublicProjection, createDefaultCostBaselineRegistry, createDefaultDependencyBuildAdapters, createDefaultDependencyManager, createDefaultDependencyResolvers, createDefaultRuntimeDrivers, createDependencyBuildBundle, createDependencyLock, createEngine, createExtendedCostBaselineRegistry, createJudgeExecutor, createReleaseManifest, createReplayBundle, createRuntimeBundleManifest, createSdkProject, decodeJudgePackageForExecution, decodeLibcxxPchManifest, decodeReplayBundle, dependencyFileTreeSha256, dependencyLockSha256, dependencyManifestSha256, deriveContestPublic, deriveJudgeData, derivePracticePublic, deterministicTranscript, encodeJudgePackage, encodeReplayBundle, fileMatcher, floatMatcher, goModuleZipHash, isBuiltinLanguage, isCostProfileFor, isToolchainLibcxxPchHeader, judgePackageSemanticDigest, judgeTranscript, normalizeDependencyNetworkAccess, normalizeDependencyNetworkScope, normalizeExecutionMetrics, normalizeOutput, parseCanonicalJsonBytes, parseJudgeAllowedProfiles, parseJudgeData, parseJudgePackageManifest, parseManagedCollectionContract, parseManagedCollectionSource, parseManagedCollectionV2, parseManagedCollectionValueV2, parseProblemBundle, parseProblemCollectionIndex, parseReleaseManifest, parseStandaloneProblemBundle, prepareArtifactInteraction, prepareArtifactRun, prepareTrustedJudgeRun, problemCollectionRevision, readJudgePackageManifest, releaseManifestBytes, releaseManifestSha256, replayBundle, replayBundleSha256, resolveArtifactCostBudget, resolveCostBudget, resolveDeterminism, resolveResourcePolicy, runConformanceHost, runConformanceMatrix, runtimeIdentityBytes, scoreJudgeDataResults, scoreProblemResults, setMatcher, sha256Matcher, snapshotBrowserToolchainSources, summarizeProblemPolicies, textMatcher, tokenMatcher, toolchainAssetSource, toolchainCacheIdentity, toolchainProfileSource, trustedJudgeSpec, unavailableExecutionMetrics, validateBrowserToolchainSources, validateJudgePackage, validateJudgeSpec, validateServerToolchainSources, validateToolchainDescriptors, validateTrustedJudgeWasm, verifyDependencyBuildBundle, verifyProblemBundleBytes, verifyProblemCollectionRevision, verifyReleaseManifestBytes, verifyRuntimeIdentity, wasmCheckerMatcher };
+export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, BrowserDependencyNetworkConsent, CONTEST_PUBLIC_PROJECTION_SCHEMA, CPP_STDLIB_CONFORMANCE_CASE, CargoLockDependencyResolver, CompilerRegistry, CostBaselineRegistry, CppLockDependencyResolver, DEFAULT_CONFORMANCE_CASES, DEFAULT_DETERMINISM, DEFAULT_RESOURCE_POLICY, DEPENDENCY_BUILD_LIMITS, DependencyManager, DependencyNetworkError, Engine, FULL_CONFORMANCE_CASES, GoLockDependencyResolver, JudgeEngine, LANGUAGES, MemoryDependencyCache, NpmLockDependencyResolver, PROBLEM_STARTER_LIMITS, PROJECT_SOURCE_LIMITS, PyPiLockDependencyResolver, REPOSITORY_AUTHORING_JUDGES_SCHEMA, RuntimeDriverRegistry, TRUSTED_JUDGE_RUNTIME_PROFILES, TRUSTED_JUDGE_WASIP1_IMPORTS, TRUSTED_JUDGE_WASM_MAX_BYTES, WASM_OJ_CONTRACT_ID, WASM_OJ_CONTRACT_VERSION, WASM_OJ_ERROR_CODES, WASM_OJ_ERROR_STAGES, WASM_OJ_JUDGE_DATA_SCHEMA, WASM_OJ_JUDGE_PACKAGE_MAGIC, WASM_OJ_JUDGE_PACKAGE_MAX_BYTES, WASM_OJ_JUDGE_PACKAGE_SCHEMA, WASM_OJ_LIBCXX_PCH_HEADER, WASM_OJ_RUNTIME_COMPONENTS, WASM_OJ_RUNTIME_IDENTITY_SHA256, WASM_OJ_SCHEMAS, WASM_OJ_STORAGE, WEIGHTED_METER_MODEL, WasmOjError, asWasmOjError, assertCompilerCacheKey, assertJudgeDataCostProfile, assertJudgeDataMatchesPracticePublic, assertJudgeGuestFilePath, assertLanguageIdentifier, assertProblemCostProfile, assertValidBuildArtifact, assertValidDependencyBuildBundle, assertValidDependencyLock, assertValidProject, assertValidReplayBundle, browserToolchainAssetBaseUrl, browserToolchainAssetUrl, canonicalJsonBytes, compareConformanceSnapshots, contestPublicProjectionBytes, costProfileId, createContestPublicProjection, createDefaultCostBaselineRegistry, createDefaultDependencyBuildAdapters, createDefaultDependencyManager, createDefaultDependencyResolvers, createDefaultRuntimeDrivers, createDependencyBuildBundle, createDependencyLock, createEngine, createExtendedCostBaselineRegistry, createJudgeExecutor, createReplayBundle, createRuntimeBundleManifest, createSdkProject, decodeJudgePackageForExecution, decodeLibcxxPchManifest, decodeReplayBundle, dependencyFileTreeSha256, dependencyLockSha256, dependencyManifestSha256, deriveContestPublic, deriveJudgeData, derivePracticePublic, deterministicTranscript, encodeJudgePackage, encodeReplayBundle, fileMatcher, floatMatcher, goModuleZipHash, isBuiltinLanguage, isCostProfileFor, isToolchainLibcxxPchHeader, judgePackageSemanticDigest, judgeTranscript, normalizeDependencyNetworkAccess, normalizeDependencyNetworkScope, normalizeExecutionMetrics, normalizeOutput, parseCanonicalJsonBytes, parseJudgeAllowedProfiles, parseJudgeData, parseJudgePackageManifest, parseProblemBundle, parseProblemCollectionIndex, parseRepositoryAuthoringJudges, parseStandaloneProblemBundle, prepareArtifactInteraction, prepareArtifactRun, prepareTrustedJudgeRun, problemCollectionRevision, readJudgePackageManifest, replayBundle, replayBundleSha256, resolveArtifactCostBudget, resolveCostBudget, resolveDeterminism, resolveResourcePolicy, runConformanceHost, runConformanceMatrix, runtimeIdentityBytes, scoreJudgeDataResults, scoreProblemResults, setMatcher, sha256Matcher, snapshotBrowserToolchainSources, summarizeProblemPolicies, textMatcher, tokenMatcher, toolchainAssetSource, toolchainCacheIdentity, toolchainProfileSource, trustedJudgeSpec, unavailableExecutionMetrics, validateBrowserToolchainSources, validateJudgePackage, validateJudgeSpec, validateServerToolchainSources, validateToolchainDescriptors, validateTrustedJudgeWasm, verifyDependencyBuildBundle, verifyProblemBundleBytes, verifyProblemCollectionRevision, verifyRuntimeIdentity, wasmCheckerMatcher };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wasm-oj/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Host-neutral compiler, runner, judge, dependency, and replay orchestration for WASM-OJ.",
   "license": "MIT",
   "author": "JacobLinCool",
@@ -43,7 +43,7 @@
     "node": ">=24.18.0 <25"
   },
   "dependencies": {
-    "@wasm-oj/contracts": "0.2.0",
+    "@wasm-oj/contracts": "0.2.1",
     "fflate": "0.8.3"
   },
   "scripts": {