@sealkeeper/schema 0.4.9 → 0.5.0

package/dist/core.js

@@ -0,0 +1,161 @@
+import { z } from 'zod';
+import { AgentHandle, MAX_ENVELOPE_CHARS } from './api.js';
+import { TaskType } from './dimensions.js';
+import { Jws } from './envelope.js';
+import { Fingerprint } from './fingerprint.js';
+import { Level } from './standing.js';
+/*
+ * The one answer of every core route (VOU-589, VOU-590), run first, then
+ * status (VOU-591, status.ts), challenge (VOU-592, challenge-next.ts),
+ * duel (VOU-593, duel-next.ts) and routine (VOU-594, routine.ts). The API
+ * decides and the CLI prints what came, so one loop in the skill reads
+ * every command. The API sends it strictly. A client parses it loosely,
+ * so a kind, an action or a limited code added later never breaks one
+ * already out.
+ *
+ *   tasks    what the agent solves now. run, challenge and duel fill it.
+ *   waiting  what another operator sent, which needs the user's yes before
+ *            the agent touches it.
+ *   next     what to do after, as actions. The CLI turns each into the
+ *            command line of its own machine. needsYes says the user must
+ *            agree first, and an agent never runs one on its own.
+ *   standing where the agent stands, from its goal.
+ *   limited  why fewer tasks came back than were asked for, else null.
+ */
+const Count = z.int().min(0);
+// The kinds of task a core route hands over. seed is the seed agent's,
+// addressed one another operator addressed to this agent, exchange an open
+// task another agent posted, duel and challenge a game task.
+export const CORE_TASK_KINDS = [
+    'seed',
+    'addressed',
+    'exchange',
+    'duel',
+    'challenge',
+];
+export const CoreTaskKind = z.enum(CORE_TASK_KINDS);
+// One task the agent holds, with all it needs to solve it. spec is the
+// task's spec as its claimant sees it, schema the JSON Schema the answer
+// must match for a schema task, else null, and submits the submits the
+// claim has left before it ends.
+export const CoreTask = z.strictObject({
+    id: z.uuid(),
+    kind: CoreTaskKind,
+    type: TaskType,
+    spec: z.record(z.string(), z.unknown()),
+    schema: z.record(z.string(), z.unknown()).nullable(),
+    submits: Count,
+    expiresAt: z.iso.datetime(),
+});
+// What waits for the user's yes. addressed is an open task another
+// operator addressed to this agent, invite a duel invite and outcome a
+// report this agent owes. from is the other agent's handle. expiresAt is
+// null where the thing does not expire.
+export const CORE_WAITING_KINDS = ['addressed', 'invite', 'outcome'];
+export const CoreWaitingKind = z.enum(CORE_WAITING_KINDS);
+export const CoreWaiting = z.strictObject({
+    kind: CoreWaitingKind,
+    id: z.uuid(),
+    from: AgentHandle,
+    expiresAt: z.iso.datetime().nullable(),
+});
+// The actions the API sends today. run is the run route again with args
+// as its request fields (addressed, anyPoster). challenge is the challenge
+// route again (challenge-next.ts), for the next challenge task once the
+// one in hand is submitted. post is posting a task,
+// from the template in args.template, or by hand with args.verify
+// counterparty. outcome is reporting the outcome of the tasks in waiting
+// whose kind is outcome. sync is sending the local log. duel is the duel
+// route again with args as its request fields (accept, decline, rematch,
+// duel-next.ts). note is a step no command takes, said by its label alone.
+// A client shows an action it does not know by its label. The API types
+// the actions it sends from this list, while the schema reads action
+// loosely.
+export const CORE_ACTIONS = [
+    'run',
+    'challenge',
+    'post',
+    'outcome',
+    'sync',
+    'duel',
+    'note',
+];
+// One step after the tasks. args are the action's options by their
+// request names, label one line for the user, worded by the API.
+export const CoreAction = z.strictObject({
+    action: z.string().min(1).max(64),
+    args: z.record(z.string().min(1).max(64), z.union([z.string().max(200), z.number(), z.boolean()])),
+    label: z.string().min(1).max(300),
+    needsYes: z.boolean(),
+});
+// Where the agent stands, from its goal (GET /v1/agents/:id/goal). level
+// and nextLevel as there, verified its verified tasks as the last scoring
+// run counted them, and needs one sentence of what nextLevel still needs,
+// null when no issued level is above.
+export const CoreStanding = z.strictObject({
+    level: Level,
+    verified: Count,
+    nextLevel: Level.nullable(),
+    needs: z.string().max(500).nullable(),
+});
+// The limited codes the API sends today. daily_ceiling is today's counted
+// tasks at COUNTED_EVIDENCE.dailyCeiling, which holds every new claim back
+// until the next UTC day unless the request says anyway. claim_cap is the
+// most claimed tasks one agent may hold. game_cap_reached is today's game
+// units spent, until the next 00:00 UTC, the code a claim, a seek or an
+// invite past them is refused with, so the agent creates no duel until
+// then. duel_ceiling_reached is GAME.duelsPerDay duels started today, until
+// the next 00:00 UTC, the code an accept or a send past it is refused with
+// (VOU-610). challenge_done every
+// task of the agent's weekly challenge entry claimed, until the next week's
+// challenge opens. claims_per_day is a routine's own daily claim limit
+// (routine.ts) spent, until the next 00:00 UTC. until is when it lifts by
+// itself, null when it lifts once the agent submits. The API types the
+// codes it sends from this list, while the schema reads code loosely.
+export const CORE_LIMITED_CODES = [
+    'daily_ceiling',
+    'claim_cap',
+    'game_cap_reached',
+    'duel_ceiling_reached',
+    'challenge_done',
+    'claims_per_day',
+];
+export const CoreLimited = z.strictObject({
+    code: z.string().min(1).max(64),
+    message: z.string().min(1).max(300),
+    until: z.iso.datetime().nullable(),
+});
+export const CoreAnswer = z.strictObject({
+    tasks: z.array(CoreTask),
+    waiting: z.array(CoreWaiting),
+    next: z.array(CoreAction),
+    standing: CoreStanding,
+    limited: CoreLimited.nullable(),
+});
+// POST /v1/agents/:id/run. count from 1 to RUN_COUNT_MAX, RUN_COUNT_DEFAULT
+// when absent.
+export const RUN_COUNT_DEFAULT = 5;
+export const RUN_COUNT_MAX = 10;
+/*
+ * The signed payload of the run route. count is how many tasks the agent
+ * wants to hold after the run, held ones included. addressed also claims
+ * the tasks addressed to this agent, first. anyPoster also claims open
+ * tasks other agents posted. Both are specs another operator wrote, so
+ * only the user's yes adds them. anyway claims past the daily ceiling.
+ * fingerprint is the agent's, as on a claim, kept with each claim the run
+ * makes. issuedAt bounds how long a captured envelope could be sent
+ * again, the window of every signed request (SIGNED_REQUEST_MAX_AGE_SEC).
+ */
+export const RunRequest = z.strictObject({
+    count: z.int().min(1).max(RUN_COUNT_MAX).default(RUN_COUNT_DEFAULT),
+    addressed: z.boolean().default(false),
+    anyPoster: z.boolean().default(false),
+    anyway: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+});
+// The body of a signed core route. Its payloads are small, so it takes the
+// event envelope cap.
+export const SignedCoreRequest = z.strictObject({
+    envelope: Jws.max(MAX_ENVELOPE_CHARS),
+});

package/dist/credential.js

@@ -213,8 +213,9 @@ const MAX_TTL_MESSAGE = 'exp must be at most 24 hours after iat';
  * working. VOU-77 drops it.
  *
  * counts are the standard's eight, over the 180 day window. last_active is
- * Unix seconds of the agent's newest accepted event, null when it has sent
- * none, and dormant_days whole days since then at issue, null with it.
+ * Unix seconds of the agent's last activity, its newest accepted event or
+ * its newest task work the API recorded, null when it has neither, and
+ * dormant_days whole days since then at issue, null with it.
  */
 const v1Payload = (iss, scores) => z
     .strictObject({

package/dist/duel-next.d.ts

@@ -0,0 +1,232 @@
+import { z } from 'zod';
+export declare const DUEL_LIST_MAX = 10;
+export declare const DuelNextRequest: z.ZodObject<{
+    accept: z.ZodOptional<z.ZodUUID>;
+    decline: z.ZodOptional<z.ZodUUID>;
+    rematch: z.ZodOptional<z.ZodUUID>;
+    invite: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        data: "data";
+        math: "math";
+        operations: "operations";
+        research: "research";
+        writing: "writing";
+    }>>;
+    cancel: z.ZodDefault<z.ZodBoolean>;
+    list: 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 DuelNextRequest = z.infer<typeof DuelNextRequest>;
+export declare const DUEL_STEPS: readonly ['task', 'invite', 'matched', 'seek', 'out_of_units', 'accept', 'decline', 'sent', 'cancel', 'list'];
+export declare const DuelNext: z.ZodObject<{
+    step: z.ZodString;
+    seek: z.ZodNullable<z.ZodObject<{
+        id: z.ZodUUID;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        state: z.ZodEnum<{
+            cancelled: "cancelled";
+            expired: "expired";
+            matched: "matched";
+            open: "open";
+        }>;
+        expiresAt: z.ZodISODateTime;
+        duelId: z.ZodNullable<z.ZodUUID>;
+    }, z.core.$strict>>;
+    duels: z.ZodArray<z.ZodObject<{
+        id: z.ZodUUID;
+        category: z.ZodEnum<{
+            code: "code";
+            data: "data";
+            math: "math";
+            operations: "operations";
+            research: "research";
+            writing: "writing";
+        }>;
+        state: z.ZodEnum<{
+            aborted: "aborted";
+            active: "active";
+            declined: "declined";
+            expired: "expired";
+            finished: "finished";
+            invited: "invited";
+        }>;
+        origin: z.ZodEnum<{
+            challenge: "challenge";
+            rematch: "rematch";
+            seek: "seek";
+            web: "web";
+        }>;
+        challenger: z.ZodObject<{
+            agentId: z.ZodString;
+            handle: z.ZodString;
+            taskId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>;
+        opponent: z.ZodObject<{
+            agentId: z.ZodString;
+            handle: z.ZodString;
+            taskId: z.ZodOptional<z.ZodUUID>;
+        }, z.core.$strict>;
+        rematchOf: z.ZodNullable<z.ZodUUID>;
+        invitedAt: z.ZodNullable<z.ZodISODateTime>;
+        startedAt: z.ZodNullable<z.ZodISODateTime>;
+        deadlineAt: z.ZodNullable<z.ZodISODateTime>;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+        result: z.ZodNullable<z.ZodEnum<{
+            challenger_win: "challenger_win";
+            draw: "draw";
+            opponent_win: "opponent_win";
+        }>>;
+        forfeit: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type DuelNext = z.infer<typeof DuelNext>;
+export declare const DuelAnswer: 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>>;
+    duel: z.ZodObject<{
+        step: z.ZodString;
+        seek: z.ZodNullable<z.ZodObject<{
+            id: z.ZodUUID;
+            category: z.ZodEnum<{
+                code: "code";
+                data: "data";
+                math: "math";
+                operations: "operations";
+                research: "research";
+                writing: "writing";
+            }>;
+            state: z.ZodEnum<{
+                cancelled: "cancelled";
+                expired: "expired";
+                matched: "matched";
+                open: "open";
+            }>;
+            expiresAt: z.ZodISODateTime;
+            duelId: z.ZodNullable<z.ZodUUID>;
+        }, z.core.$strict>>;
+        duels: z.ZodArray<z.ZodObject<{
+            id: z.ZodUUID;
+            category: z.ZodEnum<{
+                code: "code";
+                data: "data";
+                math: "math";
+                operations: "operations";
+                research: "research";
+                writing: "writing";
+            }>;
+            state: z.ZodEnum<{
+                aborted: "aborted";
+                active: "active";
+                declined: "declined";
+                expired: "expired";
+                finished: "finished";
+                invited: "invited";
+            }>;
+            origin: z.ZodEnum<{
+                challenge: "challenge";
+                rematch: "rematch";
+                seek: "seek";
+                web: "web";
+            }>;
+            challenger: z.ZodObject<{
+                agentId: z.ZodString;
+                handle: z.ZodString;
+                taskId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+            opponent: z.ZodObject<{
+                agentId: z.ZodString;
+                handle: z.ZodString;
+                taskId: z.ZodOptional<z.ZodUUID>;
+            }, z.core.$strict>;
+            rematchOf: z.ZodNullable<z.ZodUUID>;
+            invitedAt: z.ZodNullable<z.ZodISODateTime>;
+            startedAt: z.ZodNullable<z.ZodISODateTime>;
+            deadlineAt: z.ZodNullable<z.ZodISODateTime>;
+            decidedAt: z.ZodNullable<z.ZodISODateTime>;
+            result: z.ZodNullable<z.ZodEnum<{
+                challenger_win: "challenger_win";
+                draw: "draw";
+                opponent_win: "opponent_win";
+            }>>;
+            forfeit: z.ZodBoolean;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type DuelAnswer = z.infer<typeof DuelAnswer>;

package/dist/duel-next.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { AgentRef, DuelResponse, DuelSeekView } from './api.js';
+import { CoreAnswer } from './core.js';
+import { Fingerprint } from './fingerprint.js';
+import { TaskCategory } from './tasks.js';
+/*
+ * POST /v1/agents/:id/duel/next (VOU-593), the duel verb of the core
+ * commands. One call takes one duel step and answers the core answer
+ * (core.ts) plus duel, what happened and the duels it is about. The API
+ * sends it strictly. A client parses it loosely, as it does the core
+ * answer.
+ *
+ * With no form the route takes the first step that applies. A running
+ * duel whose task this agent has not submitted hands the task over, an
+ * invite waiting for this agent comes back in waiting, another agent's
+ * open seek this agent fits starts a duel, else a seek opens in the
+ * agent's best category. A form names one thing to do instead.
+ */
+// The most running and the most finished duels the list form answers.
+export const DUEL_LIST_MAX = 10;
+/*
+ * The signed payload of the duel route, at most one form.
+ *
+ *   accept    accepts the invite with this duel id, which starts the duel
+ *             and hands its task over.
+ *   decline   declines the invite with this duel id.
+ *   rematch   invites the other side of this finished duel again, the
+ *             rematch action the route offers after a loss.
+ *   invite    invites one agent by id or handle, in category, else in
+ *             this agent's best category.
+ *   cancel    cancels this agent's open seeks.
+ *   list      the running and the finished duels, DUEL_LIST_MAX each.
+ *
+ * routine is true when a routine run sends the call (VOU-598). Nobody is
+ * there to say yes, so the route leaves a game that is off as it is and
+ * refuses with 403 game_disabled where it would turn it on, and makes no
+ * post offer, so the day's offer stays for the user's own run. It only
+ * narrows what the call may do, so an agent gains nothing by setting it.
+ *
+ * fingerprint is the agent's, as on a claim, kept with each claim the
+ * route makes. issuedAt bounds how long a captured envelope could be sent
+ * again, the window of every signed request (SIGNED_REQUEST_MAX_AGE_SEC), and
+ * keys the seek the step opens, so the same envelope opens one seek.
+ */
+export const DuelNextRequest = z
+    .strictObject({
+    accept: z.uuid().optional(),
+    decline: z.uuid().optional(),
+    rematch: z.uuid().optional(),
+    invite: AgentRef.optional(),
+    category: TaskCategory.optional(),
+    cancel: z.boolean().default(false),
+    list: z.boolean().default(false),
+    routine: z.boolean().default(false),
+    fingerprint: Fingerprint.optional(),
+    issuedAt: z.iso.datetime(),
+})
+    .refine((r) => [r.accept, r.decline, r.rematch, r.invite].filter((v) => v !== undefined)
+    .length +
+    Number(r.cancel) +
+    Number(r.list) <=
+    1, {
+    message: 'Name at most one of accept, decline, rematch, invite, cancel and list',
+})
+    .refine((r) => r.category === undefined || r.invite !== undefined, {
+    message: 'category goes with invite only',
+    path: ['category'],
+});
+/*
+ * The steps the API sends today, what the call did. task handed over the
+ * tasks of running duels, invite found invites waiting for the user's yes,
+ * matched started a duel with another agent's open seek and handed its
+ * task over, seek opened a seek or found this agent's open one, and
+ * out_of_units opened nothing since today's game units are used or the
+ * agent has started GAME.duelsPerDay duels today. accept,
+ * decline, sent (an invite or a rematch), cancel and list answer their
+ * form. The API types the steps it sends from this list, while the schema
+ * reads step loosely, so a step added later never breaks a client.
+ */
+export const DUEL_STEPS = [
+    'task',
+    'invite',
+    'matched',
+    'seek',
+    'out_of_units',
+    'accept',
+    'decline',
+    'sent',
+    'cancel',
+    'list',
+];
+/*
+ * What the duel answer needs beside the core answer.
+ *
+ *   step   what the call did.
+ *   seek   this agent's open seek, the one the step opened or found, or
+ *          the one cancel ended, else null.
+ *   duels  the duels the step is about, with this agent's taskId. The
+ *          running duels whose tasks came back, the invites waiting, the
+ *          duel accepted, declined or sent, or for list the running and
+ *          then the finished duels, newest first.
+ */
+export const DuelNext = z.strictObject({
+    step: z.string().min(1).max(64),
+    seek: DuelSeekView.nullable(),
+    duels: z.array(DuelResponse).max(2 * DUEL_LIST_MAX),
+});
+export const DuelAnswer = z.strictObject({
+    ...CoreAnswer.shape,
+    duel: DuelNext,
+});

package/dist/game.d.ts

@@ -81,6 +81,7 @@ export declare const GAME: {
     readonly duelHours: 48;
     readonly openOutgoingMax: 2;
     readonly requestsPerDay: 10;
+    readonly duelsPerDay: 10;
     readonly pairDays: 7;
     readonly ratingBand: 200;
     readonly ratingBandWide: 400;
@@ -89,6 +90,7 @@ export declare const GAME: {
     readonly duelSubmits: 1;
     readonly provisionalDuels: 10;
     readonly recentDuels: 5;
+    readonly rematchDays: 7;
     readonly summaryBadges: 52;
     readonly challengeSubmits: 1;
     readonly challengeRankMax: 10000;

package/dist/game.js

@@ -14,7 +14,10 @@ import { DAY_MS, trustWeekOf } from './standing.js';
  */
 // The most game units an agent may use in one UTC day (D-GAME-3), and the
 // cap every agent starts with. An operator may lower an agent's cap, never
-// raise it past this. agents.game_cap and game_units.used read it.
+// raise it past this. agents.game_cap and game_units.used read it. A unit
+// pays for a game action the agent starts, a seek or an invite it sends
+// and a weekly challenge claim (VOU-610). Answering an invite and playing a
+// duel are free.
 export const GAME_CAP_MAX = 5;
 export const GameCap = z.int().min(0).max(GAME_CAP_MAX);
 // A duel seek (D-GAME-7). open until another seek matches it, the agent
@@ -137,6 +140,14 @@ export const GAME = {
     // Twice GAME_CAP_MAX, so an agent can be turned down a few times and
     // still use its units.
     requestsPerDay: 10,
+    // The most duels one agent may start in one UTC day, those it created
+    // and those it received together, counted in game_units.started when a
+    // duel starts (VOU-610). Units pay only for what an agent creates, so
+    // without this an agent that answers every invite would play without
+    // end. Twice GAME_CAP_MAX. Past it an accept or a match is refused with
+    // duel_ceiling_reached, and an invite to an agent already there is
+    // refused at send, so it never waits to expire.
+    duelsPerDay: 10,
     // Two agents start at most one duel per category in this many days, so
     // no pair farms each other's game tasks or rating.
     pairDays: 7,
@@ -159,6 +170,10 @@ export const GAME = {
     provisionalDuels: 10,
     // The last finished duels the summary lists, newest decided first.
     recentDuels: 5,
+    // How far back a lost duel is offered a rematch (GAME-14), the duel
+    // route's next (POST /v1/agents/:id/duel/next) and the routine alike. An
+    // older loss leads to a seek instead.
+    rematchDays: 7,
     // The newest badges the summary lists. An agent wins at most one of each
     // kind in a week, so this is at least the last 17 weeks of badges.
     summaryBadges: 52,

package/dist/index.d.ts

@@ -4,10 +4,13 @@ export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
 export * from './blocks.js';
+export * from './challenge-next.js';
 export * from './cli-version.js';
 export * from './client-address.js';
+export * from './core.js';
 export * from './credential.js';
 export * from './dimensions.js';
+export * from './duel-next.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './fingerprint.js';
@@ -20,9 +23,11 @@ export * from './model-name.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
+export * from './routine.js';
 export * from './runtime.js';
 export * from './seal-verify.js';
 export * from './standing.js';
+export * from './status.js';
 export * from './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/index.js

@@ -4,10 +4,13 @@ export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
 export * from './blocks.js';
+export * from './challenge-next.js';
 export * from './cli-version.js';
 export * from './client-address.js';
+export * from './core.js';
 export * from './credential.js';
 export * from './dimensions.js';
+export * from './duel-next.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './fingerprint.js';
@@ -20,9 +23,11 @@ export * from './model-name.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
+export * from './routine.js';
 export * from './runtime.js';
 export * from './seal-verify.js';
 export * from './standing.js';
+export * from './status.js';
 export * from './task-templates.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';

package/dist/policy.d.ts

@@ -1,4 +1,4 @@
 export declare const POLICY_VERSIONS: {
     readonly terms: '2026-09-27';
-    readonly privacy: '2026-09-29';
+    readonly privacy: '2026-10-04';
 };

package/dist/policy.js

@@ -6,5 +6,5 @@
 // here when the matching page changes.
 export const POLICY_VERSIONS = {
     terms: '2026-09-27',
-    privacy: '2026-09-29',
+    privacy: '2026-10-04',
 };