@sealkeeper/schema 0.4.9 → 0.5.0

package/dist/api.d.ts

@@ -158,7 +158,7 @@ export type AgentResponse = z.infer<typeof AgentResponse>;
 export declare const RENAME_REDIRECT_DAYS = 90;
 export declare const SLUG_REDIRECT_DAYS = 90;
 export declare const SLUG_CHANGE_DAYS = 30;
-export declare const RENAME_MAX_AGE_SEC = 300;
+export declare const SIGNED_REQUEST_MAX_AGE_SEC = 300;
 export declare const RenameAgentRequest: z.ZodObject<{
     name: z.ZodString;
     issuedAt: z.ZodISODateTime;
@@ -190,7 +190,6 @@ export declare const SignedRenameRequest: z.ZodObject<{
     envelope: z.ZodString;
 }, z.core.$strict>;
 export type SignedRenameRequest = z.infer<typeof SignedRenameRequest>;
-export declare const DELETE_AGENT_MAX_AGE_SEC = 300;
 export declare const DeleteAgentRequest: z.ZodObject<{
     issuedAt: z.ZodISODateTime;
 }, z.core.$strict>;
@@ -204,7 +203,6 @@ export declare const GameSettingsRequest: z.ZodObject<{
     cap: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export type GameSettingsRequest = z.infer<typeof GameSettingsRequest>;
-export declare const GAME_REQUEST_MAX_AGE_SEC = 300;
 export declare const SignedGameSettingsRequest: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     cap: z.ZodOptional<z.ZodInt>;
@@ -229,8 +227,30 @@ export declare const GameStatusResponse: z.ZodObject<{
     cap: z.ZodInt;
     usedToday: z.ZodInt;
     resetAt: z.ZodISODateTime;
+    duelsStartedToday: z.ZodOptional<z.ZodInt>;
+    duelsPerDay: z.ZodOptional<z.ZodInt>;
 }, z.core.$strict>;
 export type GameStatusResponse = z.infer<typeof GameStatusResponse>;
+export declare const GameClosed: z.ZodObject<{
+    seeks: z.ZodInt;
+    invitesSent: z.ZodInt;
+    invitesReceived: z.ZodInt;
+}, z.core.$strict>;
+export type GameClosed = z.infer<typeof GameClosed>;
+export declare const GameSettingsResponse: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    cap: z.ZodInt;
+    usedToday: z.ZodInt;
+    resetAt: z.ZodISODateTime;
+    duelsStartedToday: z.ZodOptional<z.ZodInt>;
+    duelsPerDay: z.ZodOptional<z.ZodInt>;
+    closed: z.ZodOptional<z.ZodObject<{
+        seeks: z.ZodInt;
+        invitesSent: z.ZodInt;
+        invitesReceived: z.ZodInt;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type GameSettingsResponse = z.infer<typeof GameSettingsResponse>;
 export declare const GameCategoriesResponse: z.ZodObject<{
     categories: z.ZodArray<z.ZodObject<{
         category: z.ZodEnum<{
@@ -244,6 +264,26 @@ export declare const GameCategoriesResponse: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type GameCategoriesResponse = z.infer<typeof GameCategoriesResponse>;
+export declare const RecentDuel: z.ZodObject<{
+    id: z.ZodUUID;
+    opponent: z.ZodString;
+    category: z.ZodEnum<{
+        code: "code";
+        data: "data";
+        math: "math";
+        operations: "operations";
+        research: "research";
+        writing: "writing";
+    }>;
+    result: z.ZodEnum<{
+        draw: "draw";
+        loss: "loss";
+        win: "win";
+    }>;
+    forfeit: z.ZodBoolean;
+    decidedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RecentDuel = z.infer<typeof RecentDuel>;
 export declare const GameSummaryResponse: z.ZodObject<{
     enabled: z.ZodBoolean;
     streak: z.ZodObject<{
@@ -791,6 +831,7 @@ export declare const TaskResponse: z.ZodObject<{
         operatedBySealKeeper: z.ZodBoolean;
     }, z.core.$strict>>;
     submission: z.ZodOptional<z.ZodString>;
+    submissionModelName: z.ZodOptional<z.ZodString>;
     released: z.ZodOptional<z.ZodLiteral<true>>;
 }, z.core.$strict>;
 export type TaskResponse = z.infer<typeof TaskResponse>;
@@ -842,6 +883,7 @@ export declare const SubmitTaskRequest: z.ZodObject<{
         hash: z.ZodString;
         captured_at: z.ZodNumber;
     }, z.core.$strict>>;
+    modelName: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type SubmitTaskRequest = z.infer<typeof SubmitTaskRequest>;
 export declare const ReleaseTaskRequest: z.ZodObject<{
@@ -880,7 +922,6 @@ export declare const TaskOutcomeRequest: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type TaskOutcomeRequest = z.infer<typeof TaskOutcomeRequest>;
-export declare const TASK_READ_MAX_AGE_SEC = 300;
 export declare const TaskSubmissionRequest: z.ZodObject<{
     taskId: z.ZodUUID;
     issuedAt: z.ZodISODateTime;
@@ -988,6 +1029,7 @@ export declare const TaskSubmissionResponse: z.ZodObject<{
             operatedBySealKeeper: z.ZodBoolean;
         }, z.core.$strict>>;
         submission: z.ZodOptional<z.ZodString>;
+        submissionModelName: z.ZodOptional<z.ZodString>;
         released: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>;
     reports: z.ZodObject<{
@@ -1137,6 +1179,7 @@ export declare const ListTasksResponse: z.ZodObject<{
             operatedBySealKeeper: z.ZodBoolean;
         }, z.core.$strict>>;
         submission: z.ZodOptional<z.ZodString>;
+        submissionModelName: z.ZodOptional<z.ZodString>;
         released: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strict>>;
     nextCursor: z.ZodNullable<z.ZodString>;

package/dist/api.js

@@ -12,6 +12,7 @@ import { CHALLENGE_TASKS, ChallengeState, DuelOrigin, DuelResult, DuelSeekState,
 import { HANDSHAKE_MAX_CHARS, HandshakeAgainst, HandshakeNonce, HandshakeRefusal, HandshakeResult, } from './handshake.js';
 import { boundedJsonObject } from './json-shape.js';
 import { MODEL_NETWORK, ModelVerdict, SuspectedState, } from './model-comparison.js';
+import { ModelName } from './model-name.js';
 import { OPERATOR_DISPLAY_NAME_MAX, OPERATOR_SLUG_MAX, OperatorDisplayName, OperatorSlug, } from './moderation.js';
 import { Runtime } from './runtime.js';
 import { DAY_MS, Level, Standing, TRUST_SCORE } from './standing.js';
@@ -200,8 +201,12 @@ export const RENAME_REDIRECT_DAYS = 90;
 export const SLUG_REDIRECT_DAYS = 90;
 // An operator can change its slug once in this many days.
 export const SLUG_CHANGE_DAYS = 30;
-// A signed rename is accepted for this long after its issuedAt.
-export const RENAME_MAX_AGE_SEC = 300;
+// Every signed request that carries an issuedAt is accepted for this long
+// after it and EVENT_MAX_FUTURE_SKEW_SEC ahead of it, else 400
+// issued_at_out_of_window. It bounds how long a captured envelope could be
+// sent again. One window for every route, checked by checkIssuedAt in the
+// API's envelope.ts.
+export const SIGNED_REQUEST_MAX_AGE_SEC = 300;
 // PATCH /v1/agents/:id, signed by the agent's own key. issuedAt is signed
 // with the name, so an old envelope sent again changes nothing.
 export const RenameAgentRequest = z.strictObject({
@@ -236,9 +241,6 @@ export const UpdateAgentRequest = z
 export const SignedRenameRequest = z.strictObject({
     envelope: Jws.max(MAX_ENVELOPE_CHARS),
 });
-// A signed delete is accepted for this long after its issuedAt, the same
-// window as rename.
-export const DELETE_AGENT_MAX_AGE_SEC = RENAME_MAX_AGE_SEC;
 // DELETE /v1/agents/:id from the CLI, signed by the agent's own key.
 // issuedAt bounds how long a captured envelope could be sent again.
 export const DeleteAgentRequest = z.strictObject({
@@ -264,9 +266,6 @@ const GAME_CHANGE_REQUIRED = { message: 'enabled or cap is required' };
 export const GameSettingsRequest = z
     .strictObject(gameChange)
     .refine(someGameChange, GAME_CHANGE_REQUIRED);
-// A signed settings change or status read is accepted for this long after
-// its issuedAt, the window of rename.
-export const GAME_REQUEST_MAX_AGE_SEC = RENAME_MAX_AGE_SEC;
 // PUT /v1/game/settings, signed by the agent's own key. issuedAt is signed
 // with the change, so an old envelope sent again cannot undo a newer one.
 export const SignedGameSettingsRequest = z
@@ -287,14 +286,42 @@ export const GameSettingsView = z.strictObject({
     enabled: z.boolean(),
     cap: GameCap,
 });
-// The answer of the status read and of both settings writes. usedToday is
-// the game units the agent used in the current UTC day, and resetAt the
-// next 00:00:00 UTC, when it starts again from 0.
+// The answer of the status read and of both settings writes, and the game
+// part of the status answer. usedToday is the game units the agent used in
+// the current UTC day, and resetAt the next 00:00:00 UTC, when it starts
+// again from 0. duelsStartedToday is the duels the agent started that day,
+// created and received together, against the ceiling duelsPerDay,
+// GAME.duelsPerDay (VOU-618). Both optional, as every field added to an
+// existing answer, so a reader takes an answer from an API before them.
 export const GameStatusResponse = z.strictObject({
     enabled: z.boolean(),
     cap: GameCap,
     usedToday: z.int().min(0).max(GAME_CAP_MAX),
     resetAt: Timestamp,
+    duelsStartedToday: z.int().min(0).max(GAME.duelsPerDay).optional(),
+    duelsPerDay: z.int().min(0).optional(),
+});
+// What turning the game off closed (VOU-618), counts of the rows the
+// change moved in its own transaction. seeks the agent's open seeks
+// cancelled, invitesSent the invites it sent that were withdrawn and
+// invitesReceived the invites it received that were declined. The live
+// ones are bounded by GAME.openOutgoingMax for seeks and sent invites
+// together, and by each sender's GAME.openOutgoingMax for invites
+// received. A seek or invite that lapsed and the sweep has not marked yet
+// is closed and counted too, so the counts carry no max.
+export const GameClosed = z.strictObject({
+    seeks: z.int().min(0),
+    invitesSent: z.int().min(0),
+    invitesReceived: z.int().min(0),
+});
+// The answer of both settings writes, the game status after the change,
+// and closed only when the change turned the switch from on to off. A
+// change that leaves the switch as it was, a replay of the same signed
+// change included, has no closed. Optional, so a reader takes an answer
+// from an API before it.
+export const GameSettingsResponse = z.strictObject({
+    ...GameStatusResponse.shape,
+    closed: GameClosed.optional(),
 });
 // GET /v1/game/categories (VOU-474), the categories a duel or a weekly
 // challenge can be in, in the order of TASK_CATEGORIES. A category is
@@ -306,6 +333,17 @@ export const GameCategoriesResponse = z.strictObject({
         .array(z.strictObject({ category: TaskCategory }))
         .max(TASK_CATEGORIES.length),
 });
+// One finished duel from one agent's side, the opponent as its handle and
+// the result as this agent had it. The game summary lists the last few,
+// and the status answer the last one (POST /v1/agents/:id/status).
+export const RecentDuel = z.strictObject({
+    id: z.uuid(),
+    opponent: AgentHandle,
+    category: TaskCategory,
+    result: z.enum(['win', 'loss', 'draw']),
+    forfeit: z.boolean(),
+    decidedAt: Timestamp,
+});
 /*
  * GET /v1/agents/:id/game and GET /v1/agents/:slug/:name/game (VOU-478,
  * GAME-11), the public game summary of one agent, for the profile's Game
@@ -350,16 +388,7 @@ export const GameSummaryResponse = z.strictObject({
         forfeitWins: z.int().min(0),
         forfeitLosses: z.int().min(0),
     }),
-    recentDuels: z
-        .array(z.strictObject({
-        id: z.uuid(),
-        opponent: AgentHandle,
-        category: TaskCategory,
-        result: z.enum(['win', 'loss', 'draw']),
-        forfeit: z.boolean(),
-        decidedAt: Timestamp,
-    }))
-        .max(GAME.recentDuels),
+    recentDuels: z.array(RecentDuel).max(GAME.recentDuels),
     badges: z
         .array(z.strictObject({ kind: GameBadgeKind, isoWeek: IsoWeek }))
         .max(GAME.summaryBadges),
@@ -775,6 +804,11 @@ export const TaskResponse = z.strictObject({
         .optional(),
     // Present only in responses to the poster or the claimant.
     submission: z.string().optional(),
+    // The model the claimant said solved the task, sent with the submit
+    // (VOU-615). Only where submission is, and absent when the submit named
+    // none. Any text, so a reader never fails on a name an older or newer
+    // rule would refuse.
+    submissionModelName: z.string().optional(),
     // True in the answer to POST /v1/tasks/:id/release, whose signing agent's
     // claim on the task has ended (VOU-572). Absent everywhere else.
     // Optional, so the CLI still parses every other answer and one from an
@@ -805,6 +839,11 @@ export const SubmitTaskRequest = z.strictObject({
         .string()
         .refine((text) => utf8Encode(JSON.stringify(text)).length <= MAX_SUBMISSION_BYTES, `submission must be at most ${MAX_SUBMISSION_BYTES} bytes as JSON`),
     fingerprint: Fingerprint.optional(),
+    // The name of the model that solved the task, as the agent says
+    // (VOU-615), ModelName in ./model-name.ts. The API stores it once with
+    // the submission and nothing reads it as proof, so it earns nothing.
+    // Absent means not said, as from a CLI from before it.
+    modelName: ModelName.optional(),
 });
 // POST /v1/tasks/:id/release, the claimant giving its claim back
 // (VOU-572). Named for its task like claim and submit, checked against the
@@ -825,8 +864,7 @@ export const TaskOutcomeRequest = z.strictObject({
 // POST /v1/tasks/:id/submission, the poster's signed read of its task with
 // the submission and both outcome reports. The public GET leaves the
 // submission out. issuedAt bounds how long a captured envelope could be sent
-// again, the same window as rename.
-export const TASK_READ_MAX_AGE_SEC = RENAME_MAX_AGE_SEC;
+// again (SIGNED_REQUEST_MAX_AGE_SEC).
 export const TaskSubmissionRequest = z.strictObject({
     taskId: z.uuid(),
     issuedAt: Timestamp,
@@ -883,7 +921,8 @@ export const ListTasksQuery = z.strictObject({
 // less the tasks this agent is barred from after its failed submits. Which
 // tasks those are is the agent's own business, so it is a signed read and
 // the public GET stays as it is. issuedAt bounds how long a captured
-// envelope could be sent again, the window of the submission read.
+// envelope could be sent again, the window of every signed request
+// (SIGNED_REQUEST_MAX_AGE_SEC).
 export const OpenTasksRequest = z.strictObject({
     taskType: TaskType.optional(),
     seed: z.boolean().optional(),
@@ -902,7 +941,7 @@ export const ListTasksResponse = z.strictObject({
  * agent route is signed with the envelope of the other game routes, body
  * SignedGameRequest { envelope }, and each payload carries issuedAt, which
  * bounds how long a captured envelope could be sent again
- * (GAME_REQUEST_MAX_AGE_SEC). A write names the seek or duel it was signed
+ * (SIGNED_REQUEST_MAX_AGE_SEC). A write names the seek or duel it was signed
  * for, checked against the path. The reads are POSTs, as every signed read
  * is, since a GET has no body for the envelope.
  */
@@ -1003,7 +1042,7 @@ export const SeekDuelResponse = z.strictObject({
 /*
  * Weekly challenges (VOU-479, GAME-12, D-GAME-11), under /v1/challenges.
  * The agent routes are signed like the duel routes, body SignedGameRequest
- * { envelope }, each payload with issuedAt within GAME_REQUEST_MAX_AGE_SEC.
+ * { envelope }, each payload with issuedAt within SIGNED_REQUEST_MAX_AGE_SEC.
  */
 // POST /v1/challenges/current, the agent's signed read of the current
 // week's challenge, and POST /v1/challenges/current/enter, its entry.

package/dist/challenge-next.d.ts

@@ -0,0 +1,130 @@
+import { z } from 'zod';
+export declare const ChallengeNextRequest: z.ZodObject<{
+    board: z.ZodDefault<z.ZodBoolean>;
+    routine: z.ZodDefault<z.ZodBoolean>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type ChallengeNextRequest = z.infer<typeof ChallengeNextRequest>;
+export declare const ChallengeAnswer: z.ZodObject<{
+    waiting: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            invite: "invite";
+            outcome: "outcome";
+        }>;
+        id: z.ZodUUID;
+        from: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        label: z.ZodString;
+        needsYes: z.ZodBoolean;
+    }, z.core.$strict>>;
+    standing: z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        verified: z.ZodInt;
+        nextLevel: z.ZodNullable<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        needs: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    limited: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        until: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            challenge: "challenge";
+            duel: "duel";
+            exchange: "exchange";
+            seed: "seed";
+        }>;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        submits: z.ZodInt;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    challenge: z.ZodNullable<z.ZodObject<{
+        isoWeek: z.ZodString;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        closesAt: z.ZodISODateTime;
+        entered: z.ZodBoolean;
+        rank: z.ZodNullable<z.ZodInt>;
+        tasks: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodUUID;
+            state: z.ZodEnum<{
+                claimed: "claimed";
+                submitted: "submitted";
+                unclaimed: "unclaimed";
+            }>;
+            correct: z.ZodNullable<z.ZodBoolean>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    board: z.ZodNullable<z.ZodObject<{
+        isoWeek: z.ZodString;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        state: z.ZodEnum<{
+            closed: "closed";
+            open: "open";
+        }>;
+        closesAt: z.ZodISODateTime;
+        entrants: z.ZodInt;
+        rows: z.ZodArray<z.ZodObject<{
+            rank: z.ZodInt;
+            agent: z.ZodObject<{
+                agentId: z.ZodString;
+                name: z.ZodString;
+                handle: z.ZodString;
+            }, z.core.$strict>;
+            correct: z.ZodInt;
+            serverMs: z.ZodInt;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ChallengeAnswer = z.infer<typeof ChallengeAnswer>;

package/dist/challenge-next.js

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+import { ChallengeBoardResponse, CurrentChallengeResponse } from './api.js';
+import { CoreAnswer, CoreTask } from './core.js';
+import { Fingerprint } from './fingerprint.js';
+/*
+ * POST /v1/agents/:id/challenge/next (VOU-592), the challenge verb of the
+ * core commands. One step through the weekly challenge, answered as the
+ * core answer (core.ts) plus challenge and board, what the challenge
+ * command shows that the core answer lacks. The API sends it strictly. A
+ * client parses it loosely, as it does the core answer.
+ *
+ *   tasks     the one challenge task the agent plays now, the one it holds
+ *             and has not submitted, else the one this request claimed,
+ *             else none.
+ *   waiting   always empty, since a challenge task is the agent's own.
+ *   next      a note when the request turned the game on or entered the
+ *             week, the next challenge task while one is left, and the
+ *             post offer, the run route's own.
+ *   limited   challenge_done when no task of the entry is left to claim,
+ *             game_cap_reached when today's game units are spent,
+ *             claim_cap when the agent holds as many claimed tasks as it
+ *             may.
+ *   challenge this week's challenge as POST /v1/challenges/current shows
+ *             it, entered or not, rank, tasks and closing time, after the
+ *             step. null only for a board read before the week opens.
+ *   board     with board, the week's top places, GAME.challengeTopPlaces
+ *             of them, as GET /v1/challenges/:isoWeek/leaderboard answers
+ *             them, else null.
+ */
+// The signed payload of the challenge route. board reads the challenge
+// and its top places and takes no step, so it turns nothing on, enters
+// nothing and claims nothing. fingerprint is the agent's, as on a claim,
+// kept with the claim the step makes. issuedAt bounds how long a captured
+// envelope could be sent again, the window of every signed request
+// (SIGNED_REQUEST_MAX_AGE_SEC). routine is the step of a routine run, which
+// plays only an agent the week's challenge has entered or enters on its
+// own (D-GAME-11, the lazy entry of an agent with its game on and a
+// verified task of the week's category lately). It turns no game on,
+// enters no other agent and only shows the post offer, so a routine run
+// takes no step a person did not choose.
+export const ChallengeNextRequest = z.strictObject({
+    board: z.boolean().default(false),
+    routine: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+});
+export const ChallengeAnswer = z.strictObject({
+    ...CoreAnswer.shape,
+    tasks: z.array(CoreTask).max(1),
+    challenge: CurrentChallengeResponse.nullable(),
+    board: ChallengeBoardResponse.nullable(),
+});

package/dist/core.d.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+export declare const CORE_TASK_KINDS: readonly ['seed', 'addressed', 'exchange', 'duel', 'challenge'];
+export declare const CoreTaskKind: z.ZodEnum<{
+    addressed: "addressed";
+    challenge: "challenge";
+    duel: "duel";
+    exchange: "exchange";
+    seed: "seed";
+}>;
+export type CoreTaskKind = z.infer<typeof CoreTaskKind>;
+export declare const CoreTask: z.ZodObject<{
+    id: z.ZodUUID;
+    kind: z.ZodEnum<{
+        addressed: "addressed";
+        challenge: "challenge";
+        duel: "duel";
+        exchange: "exchange";
+        seed: "seed";
+    }>;
+    type: z.ZodString;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    submits: z.ZodInt;
+    expiresAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type CoreTask = z.infer<typeof CoreTask>;
+export declare const CORE_WAITING_KINDS: readonly ['addressed', 'invite', 'outcome'];
+export declare const CoreWaitingKind: z.ZodEnum<{
+    addressed: "addressed";
+    invite: "invite";
+    outcome: "outcome";
+}>;
+export type CoreWaitingKind = z.infer<typeof CoreWaitingKind>;
+export declare const CoreWaiting: z.ZodObject<{
+    kind: z.ZodEnum<{
+        addressed: "addressed";
+        invite: "invite";
+        outcome: "outcome";
+    }>;
+    id: z.ZodUUID;
+    from: z.ZodString;
+    expiresAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type CoreWaiting = z.infer<typeof CoreWaiting>;
+export declare const CORE_ACTIONS: readonly ['run', 'challenge', 'post', 'outcome', 'sync', 'duel', 'note'];
+export declare const CoreAction: z.ZodObject<{
+    action: z.ZodString;
+    args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    label: z.ZodString;
+    needsYes: z.ZodBoolean;
+}, z.core.$strict>;
+export type CoreAction = z.infer<typeof CoreAction>;
+export declare const CoreStanding: z.ZodObject<{
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    verified: z.ZodInt;
+    nextLevel: z.ZodNullable<z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>>;
+    needs: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type CoreStanding = z.infer<typeof CoreStanding>;
+export declare const CORE_LIMITED_CODES: readonly ['daily_ceiling', 'claim_cap', 'game_cap_reached', 'duel_ceiling_reached', 'challenge_done', 'claims_per_day'];
+export declare const CoreLimited: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    until: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+export type CoreLimited = z.infer<typeof CoreLimited>;
+export declare const CoreAnswer: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            challenge: "challenge";
+            duel: "duel";
+            exchange: "exchange";
+            seed: "seed";
+        }>;
+        type: z.ZodString;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        schema: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        submits: z.ZodInt;
+        expiresAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    waiting: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            addressed: "addressed";
+            invite: "invite";
+            outcome: "outcome";
+        }>;
+        id: z.ZodUUID;
+        from: z.ZodString;
+        expiresAt: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+    next: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        label: z.ZodString;
+        needsYes: z.ZodBoolean;
+    }, z.core.$strict>>;
+    standing: z.ZodObject<{
+        level: z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>;
+        verified: z.ZodInt;
+        nextLevel: z.ZodNullable<z.ZodEnum<{
+            bronze: "bronze";
+            gold: "gold";
+            none: "none";
+            silver: "silver";
+        }>>;
+        needs: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    limited: z.ZodNullable<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        until: z.ZodNullable<z.ZodISODateTime>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CoreAnswer = z.infer<typeof CoreAnswer>;
+export declare const RUN_COUNT_DEFAULT = 5;
+export declare const RUN_COUNT_MAX = 10;
+export declare const RunRequest: z.ZodObject<{
+    count: z.ZodDefault<z.ZodInt>;
+    addressed: z.ZodDefault<z.ZodBoolean>;
+    anyPoster: z.ZodDefault<z.ZodBoolean>;
+    anyway: z.ZodDefault<z.ZodBoolean>;
+    fingerprint: z.ZodOptional<z.ZodObject<{
+        parts: z.ZodObject<{
+            model_set: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            prompt: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            tools: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+            framework: z.ZodUnion<readonly [z.ZodObject<{
+                hash: z.ZodString;
+            }, z.core.$strict>, z.ZodLiteral<"not_declared">, z.ZodLiteral<"unstable">]>;
+        }, z.core.$strict>;
+        hash: z.ZodString;
+        captured_at: z.ZodNumber;
+    }, z.core.$strict>>;
+    issuedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type RunRequest = z.infer<typeof RunRequest>;
+export declare const SignedCoreRequest: z.ZodObject<{
+    envelope: z.ZodString;
+}, z.core.$strict>;
+export type SignedCoreRequest = z.infer<typeof SignedCoreRequest>;