@sealkeeper/schema 0.4.5 → 0.4.7

package/dist/moderation.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { HIDDEN } from './hidden.js';
 // Moderation of the names an operator chooses, the operator slug and the
 // operator display name. The API runs these checks on every write and is
 // the only enforcement. The CLI and the web run the same checks for early
@@ -24,10 +25,6 @@ export const OperatorSlug = z
     .max(OPERATOR_SLUG_MAX)
     .regex(SLUG, 'Use lowercase letters, digits and hyphens, starting and ending with a letter or digit')
     .refine((slug) => !slug.includes('--'), 'No double hyphen');
-// Control, format, private use, unassigned and lone surrogate characters
-// (bidi overrides, zero width joiners and the like), and the line and
-// paragraph separators, which can hide, reorder or break what a reader sees.
-const HIDDEN = /[\p{C}\p{Zl}\p{Zp}]/u;
 const LETTER_OR_DIGIT = /[\p{L}\p{N}]/u;
 // The operator's display name. Free text, no control or format characters,
 // no space at either end, and at least one letter or digit, so its
@@ -42,65 +39,101 @@ export const OperatorDisplayName = z
     .refine((name) => LETTER_OR_DIGIT.test(name), 'Use at least one letter or digit');
 // ---------------------------------------------------------------------------
 // Normalisation
-// Letters from other scripts that read as a Latin letter, and a few Latin
-// letters NFKD does not split into a base and a mark.
-const HOMOGLYPHS = {
-    // Cyrillic
-    а: 'a',
-    в: 'b',
-    с: 'c',
-    ԁ: 'd',
-    е: 'e',
-    ё: 'e',
-    һ: 'h',
-    н: 'h',
-    і: 'i',
-    ї: 'i',
-    ј: 'j',
-    к: 'k',
-    ӏ: 'l',
-    м: 'm',
-    п: 'n',
-    о: 'o',
-    р: 'p',
-    ԛ: 'q',
-    г: 'r',
-    ѕ: 's',
-    т: 't',
-    у: 'y',
-    ш: 'w',
-    ԝ: 'w',
-    х: 'x',
-    // Greek
-    α: 'a',
-    β: 'b',
-    ϲ: 'c',
-    ε: 'e',
-    η: 'n',
-    ι: 'i',
-    κ: 'k',
-    μ: 'u',
-    ν: 'v',
-    ο: 'o',
-    ρ: 'p',
-    τ: 't',
-    υ: 'u',
-    χ: 'x',
-    ω: 'w',
-    // Latin letters without a decomposition
-    ı: 'i',
-    ȷ: 'j',
-    ł: 'l',
-    ø: 'o',
-    đ: 'd',
-    ħ: 'h',
-    ŧ: 't',
-    ß: 'ss',
-    æ: 'ae',
-    œ: 'oe',
-    ɡ: 'g',
-    ɑ: 'a',
-    // Digits and symbols used as letters
+// Lookalikes, folded to the Latin letter they read as. Each row is a Latin
+// letter and the letters of other scripts that read as it, in the order
+// Greek, Cyrillic, Armenian, Cherokee, Canadian syllabics, Lisu, Latin,
+// Coptic, Tifinagh. The letters come from Unicode's confusables.txt, one
+// letter to one Latin letter, for these scripts only, plus the Latin small
+// capitals and a few Latin letters NFKD does not split into a base and a
+// mark. Coptic alfa and eie (Ⲁ, Ⲉ) are added by eye, they are not in the
+// list. Letters NFKC or
+// NFKD turn into another letter (the lunate sigma, the rho symbol, ё) are
+// left out, since they never reach the tables.
+function byLetter(rows) {
+    const table = {};
+    for (const [latin, lookalikes] of Object.entries(rows)) {
+        for (const ch of lookalikes) {
+            if (ch in table)
+                throw new Error(`${ch} is in two lookalike rows`);
+            table[ch] = latin;
+        }
+    }
+    return table;
+}
+// Capitals, and letters of scripts without case, that read as a Latin
+// capital. Folded before a letter is lowercased, since lowercasing first
+// would turn Greek capital Nu into nu, which reads as v, and a Cherokee
+// capital into a Cherokee small letter. So capital Nu is n here and small
+// nu is v in SMALL_LOOKALIKES.
+const CAPITAL_LOOKALIKES = byLetter({
+    a: 'ΑАᎪᗅꓮⲀ',
+    b: 'ΒВЬᏏᏴᗷꓐⲂ',
+    c: 'СᏟꓚⲤ',
+    d: 'ᎠᏧᗞᗪꓓ',
+    e: 'ΕЕᎬꓰⲈⴹ',
+    f: 'Ϝᖴꓝ',
+    g: 'ԌᏀᏳꓖ',
+    h: 'ΗНҺᎻᏂᕼꓧⲎ',
+    i: 'ΙІᎥ',
+    j: 'ͿЈᎫᒍꓙ',
+    k: 'ΚКᏦꓗⲔ',
+    l: 'ӀᏞᒪꓡꓲǀⲒⳐⵏ',
+    m: 'ΜϺМᎷᗰꓟⲘ',
+    n: 'Ν𑪾ꓠⲚ',
+    o: 'ΟОՕꓳⲞⵔ',
+    p: 'ΡРᏢᑭꓑⲢⳎ',
+    q: 'Ԛⵕ',
+    r: 'ᎡᏒᖇꓣ',
+    s: 'ЅՏᏕᏚꓢ',
+    t: 'ΤТᎢꓔⲦ',
+    u: 'Սᑌꓴ',
+    v: 'ѴᏙᐯꓦ',
+    w: 'ԜᎳᏔꓪ',
+    x: 'ΧХꓫⲬⵝ',
+    y: 'ΥУҮᎩᎽꓬ',
+    z: 'ΖᏃ𑪼ꓜ',
+});
+// Small letters that read as a Latin letter. Cherokee small letters are the
+// Cherokee capitals above, smaller, so they are added from that table.
+const SMALL_LOOKALIKES = byLetter({
+    a: 'αаɑᴀⲁ',
+    b: 'βвᑲᖯʙⲃ',
+    c: 'сᲃᴄⲥ',
+    d: 'ԁᑯꓒđᴅ',
+    e: 'εеҽᴇⲉ',
+    f: 'քꜰ',
+    g: 'ցɡɢ',
+    h: 'һнհħʜⲏ',
+    i: 'ιіꙇւıɪɩⲓ',
+    j: 'ϳјյȷᴊ',
+    k: 'κкᴋⲕ',
+    l: 'ӏłʟⳑ',
+    m: 'мᴍ',
+    n: 'ηпոռɴⲛ',
+    o: 'οоᲂօøᴏⲟϭ',
+    p: 'ρϸрᴘⲣⳏ',
+    q: 'ԛգզꞯ',
+    r: 'ᴦгʀⲅ',
+    s: 'ѕꜱ',
+    t: 'τтŧᴛⲧ',
+    u: 'μυսᴜ',
+    v: 'νѵᴠ',
+    w: 'ωшԝѡաᴡꟺⲽ',
+    x: 'χхᕁᕽⲭ',
+    y: 'уүʏⲩ',
+    z: 'ᴢ',
+    ss: 'ß',
+    ae: 'æ',
+    oe: 'œ',
+});
+for (const [ch, latin] of Object.entries(CAPITAL_LOOKALIKES)) {
+    const small = ch.toLowerCase();
+    if (small !== ch && /\p{Script=Cherokee}/u.test(ch)) {
+        SMALL_LOOKALIKES[small] = latin;
+    }
+}
+// Digits and symbols used as letters.
+const DIGIT_SWAPS = {
     '0': 'o',
     '1': 'l',
     '3': 'e',
@@ -113,20 +146,30 @@ const HOMOGLYPHS = {
     '|': 'l',
     '!': 'l',
 };
+// One letter folded. A capital by the capital it looks like, else the
+// letter lowercased and folded by the small letter it looks like.
+function foldLetter(ch) {
+    const capital = CAPITAL_LOOKALIKES[ch];
+    if (capital !== undefined)
+        return capital;
+    const small = ch.toLowerCase();
+    return SMALL_LOOKALIKES[small] ?? DIGIT_SWAPS[small] ?? small;
+}
 // i and l look alike in many fonts (GoogIe with a capital I), so both fold
-// to l. Run after HOMOGLYPHS, so a Cyrillic і, a Greek ι or a dotless ı,
-// which fold to i there, fold on to l as well.
+// to l. Run after the lookalikes, so a Cyrillic і, a Greek ι or a dotless
+// ı, which fold to i there, fold on to l as well.
 const I_AS_L = /i/g;
 const MARKS = /\p{M}/gu;
 const NOT_LETTER_OR_DIGIT = /[^\p{L}\p{N}]/gu;
-// The form two names are compared in. NFKC, lowercase, accents dropped,
-// homoglyphs and digit swaps folded, everything but letters and digits
-// dropped, then letter pairs that read as one letter (rn as m, vv as w)
-// folded. Open-AI, OPENAI and 0penai all give the same key. Letters of
-// scripts with no Latin lookalike are kept, so a display name in another
-// script still has a key of its own.
+// The form two names are compared in. NFKC, accents dropped, lookalikes of
+// other scripts and digit swaps folded by shape and the rest lowercased,
+// everything but letters and digits dropped, then letter pairs that read
+// as one letter (rn as m, vv as w) folded. Open-AI, OPENAI and 0penai all
+// give the same key, and so does OPENAI with a Greek capital Omicron.
+// Letters of scripts with no Latin lookalike are kept, so a display name
+// in another script still has a key of its own.
 export function normaliseName(text) {
-    const folded = Array.from(text.normalize('NFKC').toLowerCase().normalize('NFKD').replace(MARKS, ''), (ch) => HOMOGLYPHS[ch] ?? ch)
+    const folded = Array.from(text.normalize('NFKC').normalize('NFKD').replace(MARKS, ''), foldLetter)
         .join('')
         .replace(I_AS_L, 'l');
     return folded
@@ -403,11 +446,62 @@ export function moderateSlug(slug) {
     }
     return protectedRefusal(slug);
 }
+// Scripts a name in Latin letters may mix with, the mixes Unicode's highly
+// restrictive profile (UTS 39) allows. Han, Hiragana, Katakana, Hangul and
+// Bopomofo, plus Common and Inherited, which hold letters every script
+// shares. Any other script mixed with Latin is how a lookalike hides (Nvidia
+// with a Greek capital Nu, Google with Armenian o, OpenAI with a Coptic O),
+// so it is refused outright, whatever the tables above fold. A script not
+// listed here is refused by default, so a new lookalike script needs no row.
+// A name written in any one script alone is fine.
+const MIXES_WITH_LATIN = /[\p{Script=Latin}\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}\p{Script=Bopomofo}\p{Script=Common}\p{Script=Inherited}]/u;
+// Names for the refusal message, for the scripts with the most Latin
+// lookalikes. Any other script is "letters of another script".
+const SCRIPT_NAMES = [
+    ['Greek letters', /\p{Script=Greek}/u],
+    ['Cyrillic letters', /\p{Script=Cyrillic}/u],
+    ['Armenian letters', /\p{Script=Armenian}/u],
+    ['Cherokee letters', /\p{Script=Cherokee}/u],
+    ['Lisu letters', /\p{Script=Lisu}/u],
+    ['Canadian syllabics', /\p{Script=Canadian_Aboriginal}/u],
+    ['Coptic letters', /\p{Script=Coptic}/u],
+    ['Tifinagh letters', /\p{Script=Tifinagh}/u],
+];
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+// The micro sign and the ohm sign. NFKC turns them into Greek mu and
+// Omega, and the ohm sign is Greek already, so they are dropped before the
+// script check. 10kΩ Audio is a unit, not a Greek letter.
+const UNIT_SIGNS = /[\u00B5\u2126]/gu;
+// The script a text mixes with Latin letters, as the refusal names it, or
+// null when it mixes none it may not. Read after NFKC, so fullwidth and
+// styled Latin letters count as Latin.
+export function mixedScriptOf(text) {
+    const letters = Array.from(text.replace(UNIT_SIGNS, '').normalize('NFKC')).filter((ch) => LETTER.test(ch));
+    if (!letters.some((ch) => LATIN.test(ch)))
+        return null;
+    const other = letters.find((ch) => !MIXES_WITH_LATIN.test(ch));
+    if (other === undefined)
+        return null;
+    const named = SCRIPT_NAMES.find(([, pattern]) => pattern.test(other));
+    return named ? named[0] : 'letters of another script';
+}
 // The refusal for an operator display name, or null when it may be used.
-// The shape is OperatorDisplayName's job. Whether another operator holds
-// the same key is the API's check against display_name_key.
+// The shape is OperatorDisplayName's job. Protected names first, then Latin
+// mixed with a script it may not mix with. Whether another operator holds
+// the same key is the API's check against display_name_key. Slugs need no
+// script check, OperatorSlug allows a to z, digits and hyphens only.
 export function moderateDisplayName(name) {
-    return protectedRefusal(name);
+    const refusal = protectedRefusal(name);
+    if (refusal)
+        return refusal;
+    const script = mixedScriptOf(name);
+    return script === null
+        ? null
+        : {
+            code: 'name_mixed_script',
+            message: `${name} mixes Latin letters with ${script}, so it can pass for another name. Use one script.`,
+        };
 }
 // ---------------------------------------------------------------------------
 // Default slugs

package/dist/seal-conformance.js

@@ -4,8 +4,8 @@ import { base64urlEncode, utf8Encode } from './base64url.js';
 import { CREDENTIAL_ISSUER, LEGACY_ISSUER_UNTIL, LEGACY_ISSUERS, SEAL_CLOCK_SKEW_SECONDS, SEAL_MAX_TTL_SECONDS, SEAL_VERSION, } from './credential.js';
 import { sign } from './envelope.js';
 const KID = 'vouched-conformance-1';
-// 1 October 2026, after LEGACY_UNTIL, so no case leans on the legacy shape,
-// and before LEGACY_ISSUER_UNTIL, so a legacy issuer is still accepted.
+// 1 October 2026, before LEGACY_ISSUER_UNTIL, so a legacy issuer is still
+// accepted.
 const NOW = 1_790_812_800;
 const LEGACY_ISSUER = LEGACY_ISSUERS[0];
 const HOUR = 3600;

package/dist/seal-verify.d.ts

@@ -0,0 +1,21 @@
+import type { SealBrokenReason } from './api.js';
+import { type SealPayload } from './credential.js';
+export type SealKey = {
+    kid: string;
+    x: string;
+};
+export type SealVerified = {
+    ok: true;
+    kid: string;
+    payload: SealPayload;
+    expiresIn: number;
+};
+export type SealProblem = {
+    ok: false;
+    reason: SealBrokenReason;
+    kid: string | null;
+    signed?: unknown;
+    payload?: SealPayload;
+};
+export type SealVerification = SealVerified | SealProblem;
+export declare function verifySeal(keys: readonly SealKey[], compact: string, nowSeconds: number): Promise<SealVerification>;

package/dist/seal-verify.js

@@ -0,0 +1,63 @@
+import { base64urlDecode } from './base64url.js';
+import { parseSealPayload, sealIatProblem, } from './credential.js';
+import { decodeHeader, EnvelopeError, verify } from './envelope.js';
+/*
+ * Verifies a SEAL against the issuer's published keys, the steps of the
+ * standard (section 3) in order. The API's POST /v1/seal/verify, the web's
+ * verify tool and badge and `sealkeeper seal verify` all call this, and the
+ * SEAL conformance cases hold it to the standard's answers.
+ *
+ * 1. The header, which names the kid. Surrounding whitespace is dropped
+ *    first, as a pasted SEAL often has it.
+ * 2. The key the kid names, among keys.
+ * 3. The signature over the exact header.payload bytes, and only then the
+ *    payload as JSON. A signature that checks out over a payload that is
+ *    not JSON is malformed, not bad_signature.
+ * 4. The issuer, then ver, then the shape for that ver, through
+ *    parseSealPayload. So a SEAL from another issuer is wrong_issuer
+ *    whatever its ver or shape.
+ * 5. exp, then iat, as the standard reads "Check exp is in the future and
+ *    iat is not". An iat more than SEAL_CLOCK_SKEW_SECONDS ahead is
+ *    not_yet_valid.
+ *
+ * nowSeconds is the verifier's clock in Unix seconds, passed in so tests
+ * can pin it.
+ */
+export async function verifySeal(keys, compact, nowSeconds) {
+    const jws = compact.trim();
+    let kid;
+    try {
+        kid = decodeHeader(jws).kid;
+    }
+    catch {
+        return { ok: false, reason: 'malformed', kid: null };
+    }
+    const key = keys.find((k) => k.kid === kid);
+    if (!key)
+        return { ok: false, reason: 'unknown_kid', kid };
+    let signed;
+    try {
+        signed = (await verify(jws, base64urlDecode(key.x))).payload;
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: error instanceof EnvelopeError && error.code === 'bad_signature'
+                ? 'bad_signature'
+                : 'malformed',
+            kid,
+        };
+    }
+    const parsed = parseSealPayload(signed, nowSeconds);
+    if (!parsed.ok)
+        return { ok: false, reason: parsed.reason, kid, signed };
+    const payload = parsed.payload;
+    const expiresIn = Math.floor(payload.exp - nowSeconds);
+    if (expiresIn <= 0) {
+        return { ok: false, reason: 'expired', kid, signed, payload };
+    }
+    const early = sealIatProblem(payload.iat, nowSeconds);
+    if (early)
+        return { ok: false, reason: early, kid, signed, payload };
+    return { ok: true, kid, payload, expiresIn };
+}

package/dist/standing.js

@@ -118,7 +118,7 @@ export const DORMANCY = {
 // (SCORING.levels in the API) and the CLI explains them, so they live here.
 // Task counts are counted evidence (CountedCounts), recalibrated on 26
 // September 2026 (VOU-139) from the simulation in
-// apps/api/src/scoring/simulation.ts. Seed tasks count in verifiedTasks at
+// apps/api/src/test/simulation.ts. Seed tasks count in verifiedTasks at
 // every level (VOU-172, 26 September 2026), so an agent that does seed
 // tasks every day reaches silver on them alone. Silver dropped its
 // checked or confirmed, other operator and confirmed task clauses then,

package/dist/tasks.d.ts

@@ -1,6 +1,8 @@
 import { z } from 'zod';
 export declare const Sha256Hex: z.ZodString;
 export declare const JSON_SCHEMA_MAX_BYTES = 16384;
+export declare const JSON_SCHEMA_MAX_DEPTH = 20;
+export declare const JSON_SCHEMA_MAX_KEYS = 500;
 export declare const HashVerification: z.ZodObject<{
     kind: z.ZodLiteral<"hash">;
     sha256: z.ZodString;

package/dist/tasks.js

@@ -1,16 +1,26 @@
 import { z } from 'zod';
-import { utf8Encode } from './base64url.js';
+import { boundedJsonObject } from './json-shape.js';
 export const Sha256Hex = z.string().regex(/^[0-9a-f]{64}$/);
 export const JSON_SCHEMA_MAX_BYTES = 16384;
+// Depth and key caps on a jsonSchema, checked before its bytes (VOU-214).
+// The depth counts JSON levels, the top level object is 1. The API's schema
+// check allows 8 schema levels (MAX_SCHEMA_DEPTH in apps/api), and a
+// subschema under properties, allOf or an items list sits two JSON levels
+// below its parent, so an accepted schema reaches about 17. 20 refuses none
+// of them and still stops a deep bracket bomb.
+export const JSON_SCHEMA_MAX_DEPTH = 20;
+export const JSON_SCHEMA_MAX_KEYS = 500;
 export const HashVerification = z.strictObject({
     kind: z.literal('hash'),
     sha256: Sha256Hex,
 });
 export const SchemaVerification = z.strictObject({
     kind: z.literal('schema'),
-    jsonSchema: z
-        .record(z.string(), z.unknown())
-        .refine((schema) => utf8Encode(JSON.stringify(schema)).length <= JSON_SCHEMA_MAX_BYTES, `jsonSchema must be at most ${JSON_SCHEMA_MAX_BYTES} bytes`),
+    jsonSchema: boundedJsonObject('jsonSchema', {
+        maxDepth: JSON_SCHEMA_MAX_DEPTH,
+        maxKeys: JSON_SCHEMA_MAX_KEYS,
+        maxBytes: JSON_SCHEMA_MAX_BYTES,
+    }),
 });
 export const CounterpartyVerification = z.strictObject({
     kind: z.literal('counterparty'),

package/package.json

@@ -1,15 +1,10 @@
 {
   "name": "@sealkeeper/schema",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "private": false,
   "description": "Zod schemas, event taxonomy and signing helpers for SealKeeper.",
   "license": "Apache-2.0",
   "homepage": "https://sealkeeper.run/seal/standard",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sealkeeper-dev/sealkeeper.git",
-    "directory": "packages/schema"
-  },
   "bugs": {
     "url": "https://github.com/sealkeeper-dev/cli/issues"
   },
@@ -33,6 +28,7 @@
   },
   "files": [
     "dist",
+    "!dist/db",
     "README.md",
     "LICENSE",
     "NOTICE"

package/dist/db/agent-milestones.d.ts

@@ -1,75 +0,0 @@
-export declare const agentMilestones: import("drizzle-orm/pg-core").PgTableWithColumns<{
-    name: "agent_milestones";
-    schema: undefined;
-    columns: {
-        createdAt: import("drizzle-orm/pg-core").PgColumn<{
-            name: "created_at";
-            tableName: "agent_milestones";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
-            name: "updated_at";
-            tableName: "agent_milestones";
-            dataType: "date";
-            columnType: "PgTimestamp";
-            data: Date;
-            driverParam: string;
-            notNull: true;
-            hasDefault: true;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: undefined;
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        agentId: import("drizzle-orm/pg-core").PgColumn<{
-            name: "agent_id";
-            tableName: "agent_milestones";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-        milestone: import("drizzle-orm/pg-core").PgColumn<{
-            name: "milestone";
-            tableName: "agent_milestones";
-            dataType: "string";
-            columnType: "PgText";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {}>;
-    };
-    dialect: 'pg';
-}>;

package/dist/db/agent-milestones.js

@@ -1,16 +0,0 @@
-import { pgTable, primaryKey, text } from 'drizzle-orm/pg-core';
-import { agents } from './agents.js';
-import { timestamps } from './timestamps.js';
-// The feed milestones an agent has reached, one row per (agent, milestone).
-// The scoring run writes a milestone to the feed only when it has no row
-// here, so each is written once per agent, ever. Migration 0019 seeded it
-// from standing, so an agent that already stood above none, or already
-// passed a verified task count, before milestones existed is not told it
-// did so for the first time.
-export const agentMilestones = pgTable('agent_milestones', {
-    agentId: text('agent_id')
-        .notNull()
-        .references(() => agents.id),
-    milestone: text('milestone').notNull(),
-    ...timestamps,
-}, (t) => [primaryKey({ columns: [t.agentId, t.milestone] })]);