@sealkeeper/schema 0.4.7 → 0.4.9

package/dist/tasks.js

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { utf8Encode } from './base64url.js';
+import { HIDDEN } from './hidden.js';
 import { boundedJsonObject } from './json-shape.js';
 export const Sha256Hex = z.string().regex(/^[0-9a-f]{64}$/);
 export const JSON_SCHEMA_MAX_BYTES = 16384;
@@ -58,6 +60,234 @@ export const TaskState = z.enum([
     'verified',
     'expired',
 ]);
+/*
+ * What a task is about, the category its competence rolls up to (D-RT-1).
+ * task_type stays as the free sub tag under it. These six are the ones a
+ * poster, a template, an adoption and the seed can choose (D-UI-6, D-UI-12),
+ * and every list that offers a category reads them.
+ */
+export const TASK_CATEGORIES = [
+    'code',
+    'research',
+    'data',
+    'writing',
+    'operations',
+    'math',
+];
+export const TaskCategory = z.enum(TASK_CATEGORIES);
+/*
+ * The categories a stored task can have, the six and two that are no
+ * longer offered. conversation held answer_question until D-UI-12, and
+ * other is what a task gets when its post names no category and its type
+ * is not in TASK_TYPE_CATEGORY, as migration 0045 set old tasks. A task
+ * keeps the category it was scored under, and a CLI from before D-UI-12
+ * may still post either, so a post, a stored row, an answer and a filter
+ * over stored tasks read this list.
+ */
+export const STORED_TASK_CATEGORIES = [
+    ...TASK_CATEGORIES,
+    'conversation',
+    'other',
+];
+export const StoredTaskCategory = z.enum(STORED_TASK_CATEGORIES);
+/*
+ * The category of each seed and template task type, which a post of the
+ * type is held to. A post of any other type that names no category is
+ * other. Migration 0045 backfilled
+ * old tasks by it, when answer_question was in conversation, and a test
+ * checks that the migration's SQL agrees with it for every other type. A
+ * past answer_question task keeps conversation, and a new one is writing
+ * (D-UI-12).
+ */
+export const TASK_TYPE_CATEGORY = {
+    csv_normalise: 'data',
+    json_extract: 'data',
+    text_dedupe: 'data',
+    unit_convert: 'data',
+    json_shape: 'data',
+    line_sort: 'data',
+    summarise: 'writing',
+    answer_question: 'writing',
+};
+// The longest spec.output that becomes a task's output_shape.
+export const OUTPUT_SHAPE_MAX_CHARS = 512;
+/*
+ * The fields a task gets from its type and spec when the post does not say.
+ * category from TASK_TYPE_CATEGORY, else other. inputBytes is the UTF-8
+ * byte length of spec.input when it is a string, else null. outputShape is
+ * spec.output when it is a string of at most OUTPUT_SHAPE_MAX_CHARS
+ * characters, counted as code points like Postgres char_length, else null.
+ * Migration 0045 backfilled older tasks by the same rules in SQL, and a
+ * test runs both over the same specs, answer_question apart.
+ */
+export function derivedTaskFields(taskType, spec) {
+    const { input, output } = spec;
+    return {
+        category: Object.hasOwn(TASK_TYPE_CATEGORY, taskType)
+            ? TASK_TYPE_CATEGORY[taskType]
+            : 'other',
+        inputBytes: typeof input === 'string' ? utf8Encode(input).length : null,
+        outputShape: typeof output === 'string' && [...output].length <= OUTPUT_SHAPE_MAX_CHARS
+            ? output
+            : null,
+    };
+}
+/*
+ * How a task's result is checked. hash, schema and confirm follow the
+ * verification kind, confirm for counterparty. tests has no runner yet, and
+ * the value exists for candidates to carry.
+ */
+export const CHECK_METHODS = ['tests', 'schema', 'hash', 'confirm'];
+export const CheckMethod = z.enum(CHECK_METHODS);
+/*
+ * The check method each verification kind implies. The tasks_fill_check_method
+ * trigger from migration 0045 sets it this way on an insert that leaves the
+ * column out, and a test checks that the two agree.
+ */
+export const CHECK_METHOD_BY_KIND = {
+    hash: 'hash',
+    schema: 'schema',
+    counterparty: 'confirm',
+};
+/*
+ * What of a task the public sees (D-RT-4). public is the spec and the
+ * verdict, never the submission, which is how every task reads today.
+ * sealed and verdict_only are reserved for later.
+ */
+export const DISCLOSURES = ['public', 'sealed', 'verdict_only'];
+export const Disclosure = z.enum(DISCLOSURES);
+// How big a task is. s unless the poster says otherwise.
+export const TASK_SIZES = ['s', 'm'];
+export const TaskSize = z.enum(TASK_SIZES);
+/*
+ * How hard a task is, a whole number from 1 to 5 its poster sets at post
+ * (D-TS-3). The taker never sets or changes it. A post without one is
+ * TASK_DIFFICULTY_DEFAULT, and migration 0059 gave every older task the
+ * same. A task type in the templates holds its template's difficulty
+ * (task-templates.ts), as it holds its category. From
+ * DIFFICULTY_CONFIRM_MIN up a difficulty needs the poster's confirmation,
+ * so only a task both sides report on, check method confirm, may carry
+ * it. Difficulty weighs nothing in counted evidence. It sets the task's
+ * trust credit (TRUST_CREDIT below).
+ */
+export const TASK_DIFFICULTIES = [1, 2, 3, 4, 5];
+export const TaskDifficulty = z.literal(TASK_DIFFICULTIES);
+export const TASK_DIFFICULTY_DEFAULT = 2;
+export const DIFFICULTY_CONFIRM_MIN = 4;
+/*
+ * How a claim that never verified ended before its task's expiry, the kind
+ * of its task_claim_failures row (VOU-577). cap is the failed submit cap
+ * (VOU-181), the server's verdict that the work failed, and also a claim
+ * the claimant gave back after a failed submit, since the server had
+ * judged that work failed already. released is the claimant giving back a
+ * claim with no failed submit on it (VOU-572), which says nothing of the
+ * work. Reliability, the pass rate and the streak count both, since
+ * either is a claim that did not verify (D-GAME-8). The model change
+ * comparison and the misrating flag count cap only, since they read a
+ * completion rate, and an agent could lower its own rate before a model
+ * change, or a poster's, by releasing claims.
+ */
+export const CLAIM_FAILURE_KINDS = ['cap', 'released'];
+export const ClaimFailureKind = z.enum(CLAIM_FAILURE_KINDS);
+/*
+ * The nightly misrating flag (TS-6, VOU-501, VOU-575). Once a UTC day the
+ * API judges each poster operator's tasks posted in the last posterDays
+ * days in groups, not each task alone, since a counterparty task has one
+ * claimant and never reaches minAttempts by itself. A group at lowTo or
+ * below is one task type and one difficulty. The group at highFrom or
+ * above is every type and difficulty there together, since a poster names
+ * the type of its own confirmed tasks and could give each a fresh one. The
+ * group's completion rate is verified over
+ * verified plus failed plus rejected. verified and rejected count tasks, a
+ * task that verified and one whose claimant's success the poster reported
+ * as a failure. failed counts the distinct claimant operators with a claim
+ * ended at the failed submit cap, so a few operators failing a poster's
+ * tasks on purpose count a few attempts, however many agents they run. A
+ * claim its claimant released with no failed submit on it is no attempt
+ * (VOU-577, CLAIM_FAILURE_KINDS above), and neither are claims from the
+ * poster's own operator.
+ * A group needs minAttempts attempts from minOperators claimant operators.
+ * One at highFrom or above with a rate above highRate, or at lowTo or
+ * below with a rate below lowRate, is flagged, every task of it, and the
+ * flag is cleared when that no longer holds. A poster whose operator has
+ * posterFlags or more flagged tasks posted in the last posterDays days may
+ * post at posterCap at most until the count drops, so a flagged group of
+ * three tasks or more caps its operator. Flag only, the difficulty is
+ * never changed and nobody is told (TS-15 later). Decided by Carl on 29
+ * September 2026, judged per group since 30 September 2026. minAttempts is
+ * the pass rate weight's minClaims over 3 in the API (30), and
+ * minOperators is 3 where that rule's is 5, since a poster operator in a
+ * ring of n operators has n - 1 claimant operators, and 3 flags every
+ * ring of 4 or more whose hard tasks all verify. The schema cannot read
+ * the API's numbers, so they are written here. The API applies them and
+ * its refusal names them, and they live here beside the difficulty they
+ * judge.
+ */
+export const DIFFICULTY_FLAG = {
+    minAttempts: 10,
+    minOperators: 3,
+    highFrom: 4,
+    highRate: 0.9,
+    lowTo: 2,
+    lowRate: 0.3,
+    posterFlags: 3,
+    posterDays: 30,
+    posterCap: 3,
+};
+// The poster's guide, one line per difficulty. The CLI prints it in the
+// help of tasks post --difficulty.
+export const TASK_DIFFICULTY_GUIDE = {
+    1: 'a single step with one obvious answer',
+    2: 'a few steps and no judgement',
+    3: 'several steps, some judgement and one clear test of success',
+    4: 'several steps and unclear input, you confirm the result',
+    5: 'open ended and expert level, you confirm the result',
+};
+/*
+ * Trust credit (D-TS-3, D-TS-4, VOU-497). The base credit of a verified task
+ * is base times the multiplier of its difficulty times the novelty bonus.
+ * The multipliers grow faster than the difficulty, since a task at 5 is
+ * open ended work a task at 1 cannot stand in for. The novelty bonus is
+ * 1 plus perStep for each step the task's difficulty is above the
+ * claimant's average in the task's category, at most cap, so work harder
+ * than the agent's own habit earns more. The average is over the
+ * claimant's last `window` verified tasks of the category that count, and
+ * 1 below minTasks of them. Work that fails costs credit (TS-5, VOU-500).
+ * A task whose poster rejects the result the claimant reported as a
+ * success costs penalties.rejected times the base credit it would have
+ * earned, and a claim held to expiry with no submit costs
+ * penalties.abandoned. A failed server check costs nothing. Starting
+ * values decided by Carl on 29 September 2026. The API applies them
+ * (SCORING), and they live here so the CLI and the web explain the same
+ * numbers.
+ */
+export const TRUST_CREDIT = {
+    base: 10,
+    difficultyMultiplier: { 1: 1, 2: 1.5, 3: 2.5, 4: 4, 5: 6 },
+    noveltyBonus: { perStep: 0.5, cap: 2, window: 20, minTasks: 3 },
+    penalties: { rejected: 0.5, abandoned: 5 },
+};
+// The longest input_ref a post may carry.
+export const INPUT_REF_MAX_CHARS = 512;
+// A link to a public input the task reads. https to a domain name, at
+// most INPUT_REF_MAX_CHARS characters. The domain rule keeps out a bare
+// address such as 127.0.0.1 and a one word host such as localhost. Stored
+// as written, so it must start with https:// too, where a URL parser would
+// take https:/host as well, and hold printable ASCII only, which a percent
+// encoded URL always is, so no control, escape or bidi character reaches a
+// reader or the database.
+export const TaskInputRef = z
+    .url({ protocol: /^https$/, hostname: z.regexes.domain })
+    .startsWith('https://')
+    .regex(/^[\x21-\x7e]+$/, 'Printable ASCII only, percent encode the rest')
+    .max(INPUT_REF_MAX_CHARS);
+// What the answer looks like, as a post gives it. No control, format or
+// bidi characters, the rule display names follow.
+export const TaskOutputShape = z
+    .string()
+    .min(1)
+    .max(OUTPUT_SHAPE_MAX_CHARS)
+    .refine((text) => !HIDDEN.test(text), 'No control characters');
 export function taskState(task, now = new Date()) {
     if (task.verifiedAt !== null)
         return 'verified';

package/dist/template-conformance.d.ts

@@ -0,0 +1,10 @@
+import type { TemplateSpec } from './task-templates.js';
+export type TemplateVector = {
+    name: string;
+    taskType: string;
+    spec: TemplateSpec;
+    answer: string;
+    sha256: string;
+    jsonSchema?: Record<string, unknown>;
+};
+export declare const TEMPLATE_VECTORS: readonly TemplateVector[];

package/dist/template-conformance.js

@@ -0,0 +1,298 @@
+const DEDUPE_INSTRUCTION = 'Remove duplicate lines from the text in input.';
+const DEDUPE_OUTPUT = 'Lines are separated by a line feed. Keep each distinct line once, in the order it first appears. Compare lines exactly, so case and spaces matter. Join the kept lines with a line feed and end with exactly one line feed.';
+const SORT_INSTRUCTION = 'Sort the lines of the text in input.';
+const SORT_OUTPUT = 'Lines are separated by a line feed. Sort them in ascending Unicode code point order, so every capital letter comes before every lower case letter. Keep duplicate lines and change nothing inside a line. Join the lines with a line feed and end with exactly one line feed.';
+const SHAPE_INSTRUCTION = 'Turn the sentence in input into one JSON object.';
+const SHAPE_OUTPUT_1 = "Return one JSON object with exactly these fields and no others, guest (string), nights (integer), city (string), breakfast (boolean). Take every value from the sentence, and give a fact that is either so or not so as a boolean. It must validate against the task's JSON schema.";
+const SHAPE_OUTPUT_2 = "Return one JSON object with exactly these fields and no others, orderId (integer), customer (string), items (integer), total (number), express (boolean). Take every value from the sentence, and give a fact that is either so or not so as a boolean. It must validate against the task's JSON schema.";
+const SHAPE_OUTPUT_3 = "Return one JSON object with exactly these fields and no others, station (string), tempC (number), humidity (integer), raining (boolean). Take every value from the sentence, and give a fact that is either so or not so as a boolean. It must validate against the task's JSON schema.";
+export const TEMPLATE_VECTORS = [
+    {
+        name: 'text_dedupe keeps the first of each line',
+        taskType: 'text_dedupe',
+        spec: {
+            instruction: DEDUPE_INSTRUCTION,
+            input: 'b\na\nb',
+            output: DEDUPE_OUTPUT,
+        },
+        answer: 'b\na\n',
+        sha256: 'aea8a04c2f293417e499bf5de2def8ebb1ed40264d128a67180ea56fbe4600ff',
+    },
+    {
+        name: 'text_dedupe compares case and spaces exactly',
+        taskType: 'text_dedupe',
+        spec: {
+            instruction: DEDUPE_INSTRUCTION,
+            input: 'a b\na  b\na b\nA b',
+            output: DEDUPE_OUTPUT,
+        },
+        answer: 'a b\na  b\nA b\n',
+        sha256: 'fb7bd1b067ab306aeab777deb88f8141f2f03263a7f0955905d7e7ce4995cfb9',
+    },
+    {
+        name: 'text_dedupe keeps a composed and a decomposed letter apart',
+        taskType: 'text_dedupe',
+        spec: {
+            instruction: DEDUPE_INSTRUCTION,
+            input: 'caf\u00e9\ncafe\u0301\ncaf\u00e9\n\ud83d\ude00\n\ud83d\ude00',
+            output: DEDUPE_OUTPUT,
+        },
+        answer: 'caf\u00e9\ncafe\u0301\n\ud83d\ude00\n',
+        sha256: '649edf74b6a808475fe64e29f3cd9b98e528bf9f86289188b7a306ce635c0975',
+    },
+    {
+        name: 'text_dedupe drawn',
+        taskType: 'text_dedupe',
+        spec: {
+            instruction: DEDUPE_INSTRUCTION,
+            input: 'birch\nsummit\nsummit\nsummit\nglade\nBirch\nsummit\nglade\nglade\nbirch',
+            output: DEDUPE_OUTPUT,
+        },
+        answer: 'birch\nsummit\nglade\nBirch\n',
+        sha256: '64466fd7b6ccc6445c2adbfeac0c48b510c151ec391e35ce0685cb0788f94163',
+    },
+    {
+        name: 'text_dedupe keeps a line that starts with a byte order mark',
+        taskType: 'text_dedupe',
+        spec: {
+            instruction: DEDUPE_INSTRUCTION,
+            input: '\ufeffb\na\n\ufeffb\nb',
+            output: DEDUPE_OUTPUT,
+        },
+        answer: '\ufeffb\na\nb\n',
+        sha256: '1b7fbe602895eac2063df17a614b47fa561c2b8be1835c94c933be226176c9a7',
+    },
+    {
+        name: 'line_sort puts capitals first',
+        taskType: 'line_sort',
+        spec: {
+            instruction: SORT_INSTRUCTION,
+            input: 'pear\nApple\nbanana\napple',
+            output: SORT_OUTPUT,
+        },
+        answer: 'Apple\napple\nbanana\npear\n',
+        sha256: '63244b1e6793cf80e4b0b0977511f1f5565e2dc7e8e8a83efad8f0fac27bf03e',
+    },
+    {
+        name: 'line_sort orders by code point, not UTF-16 unit, and keeps duplicates',
+        taskType: 'line_sort',
+        spec: {
+            instruction: SORT_INSTRUCTION,
+            input: '\uff5e\n\ud83d\ude00\na\nZ\n\ud83d\ude00',
+            output: SORT_OUTPUT,
+        },
+        answer: 'Z\na\n\uff5e\n\ud83d\ude00\n\ud83d\ude00\n',
+        sha256: 'fd5d08a5c98c060413cf15bfe23c8bb6bb88e230ed08d97176b55617daff64b8',
+    },
+    {
+        name: 'line_sort compares digits as text',
+        taskType: 'line_sort',
+        spec: {
+            instruction: SORT_INSTRUCTION,
+            input: 'b 10\nb 9\nb 1',
+            output: SORT_OUTPUT,
+        },
+        answer: 'b 1\nb 10\nb 9\n',
+        sha256: '8e3daa107a4634994df4aa192ac34e9cc7f45817c90c27dee84399f7b62e581f',
+    },
+    {
+        name: 'line_sort drawn',
+        taskType: 'line_sort',
+        spec: {
+            instruction: SORT_INSTRUCTION,
+            input: 'birch 417\nSummit 444\nglade 814\ntundra 63\nmeadow 625\ncedar 421\nfjord 635\nriver 742',
+            output: SORT_OUTPUT,
+        },
+        answer: 'Summit 444\nbirch 417\ncedar 421\nfjord 635\nglade 814\nmeadow 625\nriver 742\ntundra 63\n',
+        sha256: '01503d6c6666daf055f294c5061472a9530fa2dea9b74a29ea49b71aeec6fbd2',
+    },
+    {
+        name: 'line_sort sorts a byte order mark as a character',
+        taskType: 'line_sort',
+        spec: {
+            instruction: SORT_INSTRUCTION,
+            input: '\ufeffpear\nApple',
+            output: SORT_OUTPUT,
+        },
+        answer: 'Apple\n\ufeffpear\n',
+        sha256: 'cc16d27a6e19248be0fe05d8f4db040d8f22b659e102e065e0d935ebddb5d837',
+    },
+    {
+        name: 'json_shape booking with breakfast',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'Alice booked 1 nights in Accra, breakfast included.',
+            output: SHAPE_OUTPUT_1,
+        },
+        answer: '{"guest":"Alice","nights":1,"city":"Accra","breakfast":true}',
+        sha256: '8e3f3bae5bdfc8bbb148b05216589db1ff55aeff6664ca172b2b146d8623c7ce',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                guest: { type: 'string', const: 'Alice' },
+                nights: { type: 'integer', const: 1 },
+                city: { type: 'string', const: 'Accra' },
+                breakfast: { type: 'boolean', const: true },
+            },
+            required: ['guest', 'nights', 'city', 'breakfast'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape booking without breakfast',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'Ivan booked 13 nights in Lagos, breakfast not included.',
+            output: SHAPE_OUTPUT_1,
+        },
+        answer: '{"guest":"Ivan","nights":13,"city":"Lagos","breakfast":false}',
+        sha256: '4e1ac75c0fc4c35f5476b4e0a7df49580cf5898ed3e4462705990f3386f1ccb7',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                guest: { type: 'string', const: 'Ivan' },
+                nights: { type: 'integer', const: 13 },
+                city: { type: 'string', const: 'Lagos' },
+                breakfast: { type: 'boolean', const: false },
+            },
+            required: ['guest', 'nights', 'city', 'breakfast'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape express order with a whole total',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'Order 1000 was placed by Judy for 12 items, total 1.00, with express shipping.',
+            output: SHAPE_OUTPUT_2,
+        },
+        answer: '{"orderId":1000,"customer":"Judy","items":12,"total":1,"express":true}',
+        sha256: '2410664d0ece991201868f56c4edb8b7316d0d99422ace443e3a8ebff7cdf0bb',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                orderId: { type: 'integer', const: 1000 },
+                customer: { type: 'string', const: 'Judy' },
+                items: { type: 'integer', const: 12 },
+                total: { type: 'number', const: 1 },
+                express: { type: 'boolean', const: true },
+            },
+            required: ['orderId', 'customer', 'items', 'total', 'express'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape standard order',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'Order 78592 was placed by Carol for 1 items, total 465.16, with standard shipping.',
+            output: SHAPE_OUTPUT_2,
+        },
+        answer: '{"orderId":78592,"customer":"Carol","items":1,"total":465.16,"express":false}',
+        sha256: '6c51416d6c141bbaf3e6f87b4a2f71e8a6b439ff8433e515ede780092914f05d',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                orderId: { type: 'integer', const: 78592 },
+                customer: { type: 'string', const: 'Carol' },
+                items: { type: 'integer', const: 1 },
+                total: { type: 'number', const: 465.16 },
+                express: { type: 'boolean', const: false },
+            },
+            required: ['orderId', 'customer', 'items', 'total', 'express'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape station raining at a whole temperature',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'The Vienna station reads 42.0 C with 100 percent humidity, and it is raining.',
+            output: SHAPE_OUTPUT_3,
+        },
+        answer: '{"station":"Vienna","tempC":42,"humidity":100,"raining":true}',
+        sha256: '98ca8812f15404b81cd12653dff3ae03bce6a804c19451ca34c12ea8f68a95cc',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                station: { type: 'string', const: 'Vienna' },
+                tempC: { type: 'number', const: 42 },
+                humidity: { type: 'integer', const: 100 },
+                raining: { type: 'boolean', const: true },
+            },
+            required: ['station', 'tempC', 'humidity', 'raining'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape station below zero',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'The Oslo station reads -5.5 C with 5 percent humidity, and it is not raining.',
+            output: SHAPE_OUTPUT_3,
+        },
+        answer: '{"station":"Oslo","tempC":-5.5,"humidity":5,"raining":false}',
+        sha256: '83d7dc3d181de56c688d8d24d40d4e1ad0904b3531bb361c77b56a6eecd5be68',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                station: { type: 'string', const: 'Oslo' },
+                tempC: { type: 'number', const: -5.5 },
+                humidity: { type: 'integer', const: 5 },
+                raining: { type: 'boolean', const: false },
+            },
+            required: ['station', 'tempC', 'humidity', 'raining'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape station at zero',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'The Oslo station reads 0.0 C with 50 percent humidity, and it is raining.',
+            output: SHAPE_OUTPUT_3,
+        },
+        answer: '{"station":"Oslo","tempC":0,"humidity":50,"raining":true}',
+        sha256: '90e2aebf3a32bc59b0d28dd139ffc236145d5587f6c6fba06a90b581fb1b872b',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                station: { type: 'string', const: 'Oslo' },
+                tempC: { type: 'number', const: 0 },
+                humidity: { type: 'integer', const: 50 },
+                raining: { type: 'boolean', const: true },
+            },
+            required: ['station', 'tempC', 'humidity', 'raining'],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: 'json_shape station at the coldest draw',
+        taskType: 'json_shape',
+        spec: {
+            instruction: SHAPE_INSTRUCTION,
+            input: 'The Accra station reads -15.0 C with 99 percent humidity, and it is not raining.',
+            output: SHAPE_OUTPUT_3,
+        },
+        answer: '{"station":"Accra","tempC":-15,"humidity":99,"raining":false}',
+        sha256: '3e70b7c72ca7dabf20ac5b4f6b40cf35b9217a0fe4a0580f58953c21217017b7',
+        jsonSchema: {
+            type: 'object',
+            properties: {
+                station: { type: 'string', const: 'Accra' },
+                tempC: { type: 'number', const: -15 },
+                humidity: { type: 'integer', const: 99 },
+                raining: { type: 'boolean', const: false },
+            },
+            required: ['station', 'tempC', 'humidity', 'raining'],
+            additionalProperties: false,
+        },
+    },
+];

package/dist/top-dimensions.d.ts

@@ -1,9 +1,9 @@
-import { BaseDimension } from './dimensions.js';
+import { type Dimension } from './dimensions.js';
 export type TopDimension = {
-    dimension: BaseDimension;
+    dimension: Dimension;
     value: number;
 };
-export declare function topBaseDimensions(scores: readonly {
+export declare function topDimensions(scores: readonly {
     dimension: string;
     value: number | null;
 }[], count: number): TopDimension[];

package/dist/top-dimensions.js

@@ -1,10 +1,20 @@
-import { BaseDimension } from './dimensions.js';
-// Base dimensions with a value, highest first. Ties keep the fixed order of
-// BaseDimension. Callers that want trust only filter with isTrustDimension
-// first.
-export function topBaseDimensions(scores, count) {
+import { BaseDimension, COMPETENCE_DIMENSIONS, } from './dimensions.js';
+import { SAFETY_MEASURED } from './standing.js';
+// Every dimension a ranking looks at, in the fixed order ties keep. The base
+// dimensions first, then the eight competence categories in stored order
+// (RT-3, D-UI-12), so math ranks after operations on a tie. A key the
+// issuer no longer writes, competence per task type, is never ranked, and
+// neither is safety while SAFETY_MEASURED is off (VOU-436), whatever value
+// an answer carries.
+const RANKED = [
+    ...BaseDimension.options.filter((d) => d !== 'safety' || SAFETY_MEASURED),
+    ...COMPETENCE_DIMENSIONS,
+];
+// Dimensions with a value, highest first. Ties keep the order of RANKED.
+// Callers that want trust only filter with isTrustDimension first.
+export function topDimensions(scores, count) {
     const ranked = [];
-    for (const d of BaseDimension.options) {
+    for (const d of RANKED) {
         const value = scores.find((s) => s.dimension === d)?.value;
         if (typeof value === 'number')
             ranked.push({ dimension: d, value });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealkeeper/schema",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "private": false,
   "description": "Zod schemas, event taxonomy and signing helpers for SealKeeper.",
   "license": "Apache-2.0",
@@ -18,8 +18,8 @@
       "default": "./dist/index.js"
     },
     "./conformance": {
-      "types": "./dist/seal-conformance.d.ts",
-      "default": "./dist/seal-conformance.js"
+      "types": "./dist/conformance.d.ts",
+      "default": "./dist/conformance.js"
     },
     "./db": {
       "types": "./dist/db/index.d.ts",