@wasm-oj/organizer 0.2.0 → 0.2.1

package/README.md

@@ -1,5 +1,14 @@
 # `@wasm-oj/organizer`
 
-Schemas and publication utilities for problem collections, contest projections, and immutable
+Schemas and repository validation utilities for problem collections, contest projections, and immutable
 judge packages. The Organizer boundary validates schema, paths, size, digest, and deployability; it
 does not compile, run, score, or assess a reference solution.
+
+Contest output uses only `wasm-oj-platform/contests/v2`. Authoring presets are expanded into
+canonical typed rules before synchronization; contest v1 and unknown properties are rejected.
+
+## Upgrading from 0.2.0
+
+Managed collection parsers have been removed. Use `parseRepositoryRoot`,
+`parseRepositoryProblems`, `parseRepositoryContests`, and `validateRepositoryCatalog` for the
+repository-authored catalog. `wasm-oj.json` and its exact Git commit define catalog content.

package/dist/index.d.ts

@@ -1,5 +1,249 @@
-export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, MANAGED_COLLECTION_SCHEMA, parseManagedCollectionContract, parseManagedCollectionSource, parseManagedCollectionV2, parseManagedCollectionValueV2, parseProblemCollectionIndex, parseStandaloneProblemBundle, problemCollectionRevision, verifyProblemBundleBytes, verifyProblemCollectionRevision } from '@wasm-oj/core';
+export { BROWSER_COLLECTION_SCHEMA, BROWSER_PROBLEM_SCHEMA, parseProblemCollectionIndex, parseStandaloneProblemBundle, problemCollectionRevision, verifyProblemBundleBytes, verifyProblemCollectionRevision } from '@wasm-oj/core';
+import { BuiltinLanguage as BuiltinLanguage$1, TargetAbi, OptimizationLevel } from '@wasm-oj/contracts';
 
 declare function runCollectionCli(arguments_: readonly string[]): Promise<void>;
 
-export { runCollectionCli };
+declare const LANGUAGES: readonly ["c", "cpp", "rust", "python", "javascript", "typescript", "go"];
+type BuiltinLanguage = (typeof LANGUAGES)[number];
+
+declare const SUBMISSION_VERDICTS: readonly ["accepted", "wrong-answer", "runtime-error", "instruction-limit", "memory-limit", "output-limit", "filesystem-limit", "logical-time-limit", "wall-time-limit", "compile-error", "judge-error", "cancelled"];
+type SubmissionVerdict = typeof SUBMISSION_VERDICTS[number];
+
+type ContestEvidenceAt = "input-admitted" | "generated-source-ready" | "judge-terminal";
+interface GlobalContestClock {
+    readonly kind: "global";
+    readonly registrationOpensAt: string;
+    readonly registrationClosesAt: string;
+    readonly startsAt: string;
+    readonly durationSeconds: number;
+}
+interface IndividualContestClock {
+    readonly kind: "individual";
+    readonly enrollmentOpensAt: string;
+    readonly enrollmentClosesAt: string;
+    readonly durationSeconds: number;
+}
+type ContestClock = GlobalContestClock | IndividualContestClock;
+interface CodeOfficialTrack {
+    readonly kind: "code";
+    readonly aiAssist: "allowed" | "disabled";
+}
+interface PromptCompilerPin {
+    readonly configId: string;
+    readonly configDigest: string;
+}
+interface PromptProgramLimits {
+    readonly promptBytes: number;
+    readonly inputTokens: number;
+    readonly outputTokens: number;
+    readonly generatedSourceBytes: number;
+    readonly timeoutSeconds: number;
+}
+interface PromptAttemptPolicy {
+    readonly consumeOn: "model-response-received";
+    readonly terminalInfrastructureFailure: "release-reservation";
+}
+interface PromptProgramOfficialTrack {
+    readonly kind: "prompt-program";
+    readonly compiler: PromptCompilerPin;
+    readonly limits: PromptProgramLimits;
+    readonly attemptPolicy: PromptAttemptPolicy;
+    readonly disclosure: "private" | "best-after-end";
+}
+interface ContestProblemRuleBase {
+    readonly slug: string;
+    readonly batch: number;
+    readonly releaseAfterSeconds: number;
+    readonly submissionClosesAfterSeconds: number;
+    readonly points: number;
+    readonly attemptLimit: number;
+}
+interface CodeContestProblemRule extends ContestProblemRuleBase {
+    readonly output?: never;
+}
+interface PromptProgramOutputProfile {
+    readonly language: BuiltinLanguage$1;
+    readonly target: TargetAbi;
+    readonly optimization: OptimizationLevel;
+    readonly entry: string;
+}
+interface PromptProgramContestProblemRule extends ContestProblemRuleBase {
+    readonly output: PromptProgramOutputProfile;
+}
+type ScoreTieBreak = "fully-passed-cases" | "deterministic-cost" | "peak-memory" | "final-best-achieved-at";
+interface ScoreContestScoring {
+    readonly kind: "score";
+    readonly tieBreaks: readonly ScoreTieBreak[];
+}
+type IcpcTieBreak = "last-solve-at" | "deterministic-cost" | "peak-memory";
+interface IcpcContestScoring {
+    readonly kind: "icpc";
+    readonly wrongAttemptPenaltyMinutes: number;
+    readonly penalizedVerdicts: readonly SubmissionVerdict[];
+    readonly tieBreaks: readonly IcpcTieBreak[];
+}
+type ProgressTieBreak = "fully-passed-cases" | "deterministic-cost" | "peak-memory" | "final-best-achieved-at";
+interface ProgressContestScoring {
+    readonly kind: "progress";
+    readonly tieBreaks: readonly ProgressTieBreak[];
+}
+type ContestScoring = ScoreContestScoring | IcpcContestScoring | ProgressContestScoring;
+type ContestCheckpointScope = {
+    readonly kind: "all-released";
+} | {
+    readonly kind: "batch";
+    readonly batch: number;
+} | {
+    readonly kind: "problems";
+    readonly slugs: readonly string[];
+};
+interface ContestCheckpointThreshold {
+    readonly minimumSolved: number | null;
+    readonly minimumScore: number | null;
+}
+type ContestCheckpointRanking = {
+    readonly kind: "top-k";
+    readonly count: number;
+} | {
+    readonly kind: "top-percent";
+    readonly percent: number;
+} | null;
+interface ContestCheckpointRule {
+    readonly id: string;
+    readonly atSeconds: number;
+    readonly scope: ContestCheckpointScope;
+    readonly threshold: ContestCheckpointThreshold;
+    readonly ranking: ContestCheckpointRanking;
+    readonly settlement: "provisional" | "pause-until-terminal";
+}
+type ContestLeaderboardRule = {
+    readonly kind: "live";
+} | {
+    readonly kind: "freeze";
+    readonly atSeconds: number;
+} | {
+    readonly kind: "hidden-until-end";
+};
+interface ContestRulesBase {
+    readonly clock: ContestClock;
+    readonly evidenceAt: ContestEvidenceAt;
+    readonly scoring: ContestScoring;
+    readonly checkpoints: readonly ContestCheckpointRule[];
+    readonly leaderboard: ContestLeaderboardRule;
+}
+interface CodeContestRules extends ContestRulesBase {
+    readonly officialTrack: CodeOfficialTrack;
+    readonly problems: readonly CodeContestProblemRule[];
+}
+interface PromptProgramContestRules extends ContestRulesBase {
+    readonly officialTrack: PromptProgramOfficialTrack;
+    readonly problems: readonly PromptProgramContestProblemRule[];
+}
+type ContestRules = CodeContestRules | PromptProgramContestRules;
+
+declare const REPOSITORY_SCHEMA = "wasm-oj-platform/repository/v1";
+declare const PROBLEMS_SCHEMA = "wasm-oj-platform/problems/v1";
+declare const CONTESTS_SCHEMA = "wasm-oj-platform/contests/v2";
+interface RepositoryObjectDescriptor {
+    readonly path: string;
+    readonly bytes: number;
+    readonly sha256: string;
+}
+interface LocalizedText {
+    readonly "zh-TW": string;
+    readonly en: string;
+}
+interface RepositoryRootManifest {
+    readonly schema: typeof REPOSITORY_SCHEMA;
+    readonly problems: string;
+    readonly contests: string;
+}
+interface RepositoryProblem {
+    readonly slug: string;
+    readonly order: number;
+    readonly title: LocalizedText;
+    readonly summary: LocalizedText;
+    readonly practiceEnabled: boolean;
+    readonly practiceBundle: RepositoryObjectDescriptor;
+    readonly contestBundle: RepositoryObjectDescriptor;
+    readonly judgePackage: RepositoryObjectDescriptor;
+}
+interface RepositoryProblemsManifest {
+    readonly schema: typeof PROBLEMS_SCHEMA;
+    readonly problems: readonly RepositoryProblem[];
+}
+type RepositoryContestStatus = "draft" | "published" | "archived";
+type RepositoryContestAccessMode = "public" | "invite";
+interface RepositoryContest {
+    readonly slug: string;
+    readonly status: RepositoryContestStatus;
+    readonly title: string;
+    readonly description: string;
+    readonly accessMode: RepositoryContestAccessMode;
+    readonly rules: ContestRules;
+}
+interface RepositoryContestsManifest {
+    readonly schema: typeof CONTESTS_SCHEMA;
+    readonly contests: readonly RepositoryContest[];
+}
+interface RepositoryCatalog {
+    readonly root: RepositoryRootManifest;
+    readonly problems: RepositoryProblemsManifest;
+    readonly contests: RepositoryContestsManifest;
+}
+declare function parseRepositoryRootValue(value: unknown): RepositoryRootManifest;
+declare function parseRepositoryRoot(bytes: Uint8Array): RepositoryRootManifest;
+declare function parseRepositoryProblemsValue(value: unknown): RepositoryProblemsManifest;
+declare function parseRepositoryProblems(bytes: Uint8Array): RepositoryProblemsManifest;
+declare function parseRepositoryContestsValue(value: unknown): RepositoryContestsManifest;
+declare function parseRepositoryContests(bytes: Uint8Array): RepositoryContestsManifest;
+declare function validateRepositoryCatalog(root: RepositoryRootManifest, problems: RepositoryProblemsManifest, contests: RepositoryContestsManifest): RepositoryCatalog;
+
+interface JudgeAllowedProfile {
+    readonly target: "wasip1" | "wasix";
+    readonly optimization: "debug" | "release";
+}
+type JudgeAllowedProfiles = Readonly<Partial<Record<BuiltinLanguage, JudgeAllowedProfile>>>;
+
+type TrustedJudgeRuntimeProfile = "c-wasip1-release" | "cpp-wasip1-release" | "rust-wasip1-release" | "go-wasip1-release";
+
+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 RepositorySourceArtifact extends RepositorySourceObject {
+    readonly runtimeProfile: TrustedJudgeRuntimeProfile;
+}
+interface RepositorySourceAsset extends RepositorySourceObject {
+    readonly guestPath: string;
+}
+type RepositorySourceJudge = {
+    readonly kind: "text";
+} | {
+    readonly kind: "checker";
+    readonly artifact: RepositorySourceArtifact;
+    readonly assets: readonly RepositorySourceAsset[];
+    readonly args: readonly string[];
+} | {
+    readonly kind: "interactive";
+    readonly artifact: RepositorySourceArtifact;
+    readonly assets: readonly RepositorySourceAsset[];
+    readonly args: readonly string[];
+    readonly inputPath: string;
+};
+interface RepositoryAuthoringJudgeProblem {
+    readonly slug: string;
+    readonly allowedProfiles: JudgeAllowedProfiles;
+    readonly judge: RepositorySourceJudge;
+}
+interface RepositoryAuthoringJudges {
+    readonly schema: typeof REPOSITORY_AUTHORING_JUDGES_SCHEMA;
+    readonly problems: readonly RepositoryAuthoringJudgeProblem[];
+}
+/** Author-only input used by collection build; never accepted by the platform sync boundary. */
+declare function parseRepositoryAuthoringJudges(value: unknown): RepositoryAuthoringJudges;
+
+export { CONTESTS_SCHEMA, PROBLEMS_SCHEMA, REPOSITORY_AUTHORING_JUDGES_SCHEMA, REPOSITORY_SCHEMA, parseRepositoryAuthoringJudges, parseRepositoryContests, parseRepositoryContestsValue, parseRepositoryProblems, parseRepositoryProblemsValue, parseRepositoryRoot, parseRepositoryRootValue, runCollectionCli, validateRepositoryCatalog };
+export type { RepositoryCatalog, RepositoryContest, RepositoryObjectDescriptor, RepositoryProblem, RepositoryRootManifest };