@sealkeeper/schema 0.4.5 → 0.4.7

package/dist/credential.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { AgentId, Ed25519PublicKey } from './agent-id.js';
 import { Dimension } from './dimensions.js';
 import { Jws } from './envelope.js';
-import { Version } from './events.js';
+import { StoredVersion } from './events.js';
 import { CountedCounts, Level, StandingCounts } from './standing.js';
 // The issuer every SEAL carries as iss from the SealKeeper cutover on.
 export const CREDENTIAL_ISSUER = 'sealkeeper.run';
@@ -29,7 +29,6 @@ export function acceptedIssuer(iss, nowSeconds) {
 export const WELL_KNOWN_PATH = '/.well-known/seal.json';
 export const LEGACY_WELL_KNOWN_PATH = '/.well-known/vouched.json';
 export const WELL_KNOWN_URL = `https://${CREDENTIAL_ISSUER}${WELL_KNOWN_PATH}`;
-export const LEGACY_WELL_KNOWN_URL = `https://vouched.run${LEGACY_WELL_KNOWN_PATH}`;
 // The card extension a SEAL travels under. The two old URIs are kept beside
 // it for one release, VOU-77 drops them.
 export const SEAL_EXTENSION_URI = 'https://sealkeeper.run/ext/seal/v1';
@@ -56,12 +55,6 @@ export const SEAL_VERSION = 1;
 // writing version 1 until they are gone, and verifiers from this release
 // on accept both. SEAL standard section 9.
 export const SEAL_VERSIONS = [1, 2];
-// SEALs issued before version 1 carry no ver. Verifiers accept them as
-// legacy until the end of 25 September 2026 UTC, which is past the 24 hour
-// life of any SEAL issued before the deploy. From then on a SEAL without
-// ver is broken, unsupported_version. Unix seconds, the first second no
-// longer accepted.
-export const LEGACY_UNTIL = Date.UTC(2026, 8, 26) / 1000;
 // One identity attestation reference, SEAL standard section 4a. A pointer
 // to an attestation an external provider made, never the attestation, a
 // name or a tenant id. kind is one of the four names or a URL for anything
@@ -118,8 +111,8 @@ const v1Payload = (iss) => z
     ver: z.literal(SEAL_VERSION),
     iat: Seconds,
     exp: Seconds,
-    agent_version: Version,
-    version: Version,
+    agent_version: StoredVersion,
+    version: StoredVersion,
     level: Level,
     scores: Scores,
     counts: StandingCounts,
@@ -143,8 +136,8 @@ const v2Payload = (iss) => z
     ver: z.literal(2),
     iat: Seconds,
     exp: Seconds,
-    agent_version: Version,
-    version: Version,
+    agent_version: StoredVersion,
+    version: StoredVersion,
     level: Level,
     scores: Scores,
     counts: StandingCounts,
@@ -160,65 +153,38 @@ const v2Payload = (iss) => z
     .refine((c) => c.counted.seed_tasks <= c.counts.seed_tasks &&
     c.counted.server_checked_tasks <= c.counts.server_checked_tasks &&
     c.counted.confirmed_tasks <= c.counts.confirmed_tasks, 'counted must not exceed counts');
-// The payload issued before version 1, with no ver. Accepted by verifiers
-// until LEGACY_UNTIL, never issued again. seed_tasks is optional because a
-// SEAL issued before it was added has none.
-const legacyPayload = (iss) => z
-    .strictObject({
-    iss,
-    sub: AgentId,
-    iat: Seconds,
-    exp: Seconds,
-    version: Version,
-    scores: Scores,
-    counts: z.strictObject({
-        events: Count,
-        verified_tasks: Count,
-        seed_tasks: Count.optional(),
-    }),
-})
-    .refine((c) => c.exp > c.iat, 'exp must be after iat')
-    .refine(withinMaxTtl, MAX_TTL_MESSAGE);
 // The issuer side. iss is CREDENTIAL_ISSUER only.
 export const CredentialPayload = v1Payload(IssuedIssuer);
 export const CredentialPayloadV2 = v2Payload(IssuedIssuer);
-export const LegacyCredentialPayload = legacyPayload(IssuedIssuer);
 // The verifier side. iss may also be a LEGACY_ISSUERS entry. The shape has
 // no clock, so read these through parseSealPayload, never on their own.
 export const VerifiedCredentialPayload = v1Payload(VerifiedIssuer);
 export const VerifiedCredentialPayloadV2 = v2Payload(VerifiedIssuer);
-export const VerifiedLegacyCredentialPayload = legacyPayload(VerifiedIssuer);
-// Any payload a verifier accepts today, version 1, version 2 or legacy,
-// from the current issuer or a legacy one.
+// Any payload a verifier accepts today, version 1 or version 2, from the
+// current issuer or a legacy one. Version 2 has every version 1 field with
+// the same meaning, so a reader of version 1 fields takes both.
 export const SealPayload = z.union([
     VerifiedCredentialPayload,
     VerifiedCredentialPayloadV2,
-    VerifiedLegacyCredentialPayload,
 ]);
-// A versioned payload carries every legacy field too, so the guard is on
-// ver, the narrower of the two. Its false branch is the legacy shape. The
-// name is kept from when version 1 was the only one.
-export const isSealV1 = (p) => 'ver' in p;
 // The counted evidence a SEAL carries, version 2 on, null before.
 export const sealCounted = (p) => 'counted' in p ? p.counted : null;
 const hasVer = (raw) => typeof raw === 'object' && raw !== null && 'ver' in raw;
 /*
  * Whether a verifier understands the version of a signed payload. Read
  * after the signature and the issuer check out and before the shape. ver 1
- * and 2 (SEAL_VERSIONS) are understood. Any other ver is unsupported_version, as section 9 of the
- * standard says, never valid with an unknown meaning. No ver at all is a
- * legacy SEAL, accepted before LEGACY_UNTIL and unsupported_version from
- * then on. Anything that is not an object is left to the shape check.
+ * and 2 (SEAL_VERSIONS) are understood. Any other ver is
+ * unsupported_version, as section 9 of the standard says, never valid with
+ * an unknown meaning. So is no ver at all, a SEAL issued before version 1,
+ * whose last one expired on 26 September 2026. Anything that is not an
+ * object is left to the shape check.
  */
-export function sealVersionProblem(raw, nowSeconds) {
+export function sealVersionProblem(raw) {
     if (typeof raw !== 'object' || raw === null)
         return null;
-    if (hasVer(raw)) {
-        return SEAL_VERSIONS.includes(raw.ver)
-            ? null
-            : 'unsupported_version';
-    }
-    return nowSeconds < LEGACY_UNTIL ? null : 'unsupported_version';
+    return hasVer(raw) && SEAL_VERSIONS.includes(raw.ver)
+        ? null
+        : 'unsupported_version';
 }
 /*
  * The iat half of step 4 of the standard, section 3. "Check exp is in the
@@ -232,9 +198,8 @@ export function sealIatProblem(iat, nowSeconds) {
     return iat - nowSeconds > SEAL_CLOCK_SKEW_SECONDS ? 'not_yet_valid' : null;
 }
 // The issuer, then the version check above, then the shape for that
-// version, in the standard's order. The API and the web read a verified
-// payload through this. The CLI, which reads payloads loosely, calls
-// acceptedIssuer and sealVersionProblem itself.
+// version, in the standard's order. verifySeal reads a verified payload
+// through this.
 export function parseSealPayload(raw, nowSeconds) {
     const iss = typeof raw === 'object' && raw !== null && 'iss' in raw
         ? raw.iss
@@ -242,14 +207,12 @@ export function parseSealPayload(raw, nowSeconds) {
     if (!acceptedIssuer(iss, nowSeconds)) {
         return { ok: false, reason: 'wrong_issuer' };
     }
-    const problem = sealVersionProblem(raw, nowSeconds);
+    const problem = sealVersionProblem(raw);
     if (problem)
         return { ok: false, reason: problem };
-    const parsed = (!hasVer(raw)
-        ? VerifiedLegacyCredentialPayload
-        : raw.ver === 2
-            ? VerifiedCredentialPayloadV2
-            : VerifiedCredentialPayload).safeParse(raw);
+    const parsed = (hasVer(raw) && raw.ver === 2
+        ? VerifiedCredentialPayloadV2
+        : VerifiedCredentialPayload).safeParse(raw);
     return parsed.success
         ? { ok: true, payload: parsed.data }
         : { ok: false, reason: 'malformed' };
@@ -314,9 +277,8 @@ export const AgentSkill = z.strictObject({
     examples: z.array(z.string().min(1).max(1024)).max(32).optional(),
 });
 const Modes = z.array(z.string().min(1).max(128)).max(32).default(['text']);
-// The subset of the A2A agent card that Vouched emits, strict so the CLI
-// never writes a field it did not mean to. Reading someone else's card uses
-// the loose AgentCardResponse instead.
+// The subset of the A2A agent card that SealKeeper emits, strict so the
+// CLI never writes a field it did not mean to.
 export const AgentCard = z.strictObject({
     protocolVersion: z.literal(A2A_PROTOCOL_VERSION),
     name: z.string().min(1).max(128),

package/dist/events.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const StoredVersion: z.ZodString;
 export declare const Version: z.ZodString;
 export declare const EventType: z.ZodEnum<{
     incident: "incident";

package/dist/events.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { TaskType } from './dimensions.js';
+import { HIDDEN } from './hidden.js';
 import { Sha256Hex, TaskOutcome } from './tasks.js';
 /*
  * The Zod pattern, shown once. Every schema file in this package follows it.
@@ -25,7 +26,18 @@ import { Sha256Hex, TaskOutcome } from './tasks.js';
  *
  * Use parse to throw on bad input and safeParse to get { success, data, error }.
  */
-export const Version = z.string().min(1).max(32);
+/*
+ * An agent version as it is stored and read back. Only the length rule,
+ * since a row written before Version had a character rule may hold
+ * anything. Every answer and every read of a stored row uses this, so an
+ * old stored version never throws. New input is parsed with Version.
+ */
+export const StoredVersion = z.string().min(1).max(32);
+// An agent version as a caller sends it, in an event, a registration or a
+// version change. It is signed into the SEAL and shown on public pages, so
+// it refuses the characters OperatorDisplayName refuses (HIDDEN) and a
+// space at either end, on top of the length rule.
+export const Version = StoredVersion.refine((v) => !HIDDEN.test(v), 'No control characters').refine((v) => v === v.trim(), 'No space at the start or end');
 const Name = z
     .string()
     .min(1)

package/dist/goal.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { AgentId } from './agent-id.js';
-import { Version } from './events.js';
+import { StoredVersion } from './events.js';
 import { LADDER, Level } from './standing.js';
 // GET /v1/agents/:id/goal. What the agent's current version needs for its
 // next level, threshold by threshold, and what to do next. The API sends
@@ -158,7 +158,7 @@ export const GoalPending = z.strictObject({
 });
 export const GoalResponse = z.strictObject({
     agentId: AgentId,
-    version: Version,
+    version: StoredVersion,
     level: Level,
     nextLevel: Level.nullable(),
     ladder: z.array(GoalLadderStep),

package/dist/hidden.d.ts

@@ -0,0 +1 @@
+export declare const HIDDEN: RegExp;

package/dist/hidden.js

@@ -0,0 +1,5 @@
+// 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.
+// Shared by the text rules in this package and not exported from it.
+export const HIDDEN = /[\p{C}\p{Zl}\p{Zp}]/u;

package/dist/index.d.ts

@@ -3,16 +3,18 @@ export * from './agent-name.js';
 export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
+export * from './client-address.js';
 export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './goal.js';
+export * from './json-shape.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
 export * from './runtime.js';
+export * from './seal-verify.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';
-export declare const SCHEMA_VERSION = 1;

package/dist/index.js

@@ -3,16 +3,18 @@ export * from './agent-name.js';
 export * from './api.js';
 export * from './badge.js';
 export * from './base64url.js';
+export * from './client-address.js';
 export * from './credential.js';
 export * from './dimensions.js';
 export * from './envelope.js';
 export * from './events.js';
 export * from './goal.js';
+export * from './json-shape.js';
 export * from './moderation.js';
 export * from './operator-domains.js';
 export * from './policy.js';
 export * from './runtime.js';
+export * from './seal-verify.js';
 export * from './standing.js';
 export * from './tasks.js';
 export * from './top-dimensions.js';
-export const SCHEMA_VERSION = 1;

package/dist/json-shape.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export type JsonShapeLimits = {
+    readonly maxDepth: number;
+    readonly maxKeys: number;
+    readonly maxBytes: number;
+};
+export type JsonShapeIssue = 'too_deep' | 'too_many_keys';
+export declare function jsonShapeIssue(value: unknown, limits: Pick<JsonShapeLimits, 'maxDepth' | 'maxKeys'>): JsonShapeIssue | null;
+export declare function boundedJsonObject(name: string, limits: JsonShapeLimits): z.ZodRecord<z.ZodString, z.ZodUnknown>;

package/dist/json-shape.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { utf8Encode } from './base64url.js';
+/*
+ * The first depth or key count limit a JSON value breaks, or null when it
+ * keeps to both.
+ *
+ * Walks with its own stack rather than recursing, so a value nested
+ * thousands deep cannot overflow the call stack, and stops at the first
+ * breach. Run it before JSON.stringify on anything a caller sent.
+ * stringify recurses and throws RangeError past about 7,700 levels, and
+ * indented output grows with the square of the depth (VOU-214).
+ */
+export function jsonShapeIssue(value, limits) {
+    const stack = [];
+    const push = (v, depth) => {
+        if (typeof v === 'object' && v !== null)
+            stack.push({ node: v, depth });
+    };
+    push(value, 1);
+    let keys = 0;
+    for (let top = stack.pop(); top !== undefined; top = stack.pop()) {
+        if (top.depth > limits.maxDepth)
+            return 'too_deep';
+        let children;
+        if (Array.isArray(top.node)) {
+            children = top.node;
+        }
+        else {
+            children = Object.values(top.node);
+            keys += children.length;
+            if (keys > limits.maxKeys)
+                return 'too_many_keys';
+        }
+        for (const child of children)
+            push(child, top.depth + 1);
+    }
+    return null;
+}
+/*
+ * A JSON object held to the limits. The depth and key checks run first, so
+ * the byte check only ever stringifies a value that cannot throw, and a
+ * breach is a Zod issue (a 400 at the API), never a RangeError (a 500).
+ * superRefine is used rather than refine so each breach gets its own
+ * message and the byte check can be skipped once one is found.
+ */
+export function boundedJsonObject(name, limits) {
+    return z.record(z.string(), z.unknown()).superRefine((value, ctx) => {
+        const issue = jsonShapeIssue(value, limits);
+        if (issue === 'too_deep') {
+            ctx.addIssue({
+                code: 'custom',
+                message: `${name} must nest at most ${limits.maxDepth} levels deep`,
+            });
+            return;
+        }
+        if (issue === 'too_many_keys') {
+            ctx.addIssue({
+                code: 'custom',
+                message: `${name} must have at most ${limits.maxKeys} keys`,
+            });
+            return;
+        }
+        if (utf8Encode(JSON.stringify(value)).length > limits.maxBytes) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `${name} must be at most ${limits.maxBytes} bytes`,
+            });
+        }
+    });
+}

package/dist/moderation.d.ts

@@ -15,12 +15,13 @@ export declare const PROTECTED_PREFIXES: readonly string[];
 export declare function protectedNameOf(text: string): string | null;
 export declare const RESERVED_WORDS: readonly string[];
 export declare function isReservedWord(text: string): boolean;
-export type NameRefusalCode = 'name_protected' | 'name_reserved';
+export type NameRefusalCode = 'name_protected' | 'name_reserved' | 'name_mixed_script';
 export type NameRefusal = {
     code: NameRefusalCode;
     message: string;
 };
 export declare function moderateSlug(slug: string): NameRefusal | null;
+export declare function mixedScriptOf(text: string): string | null;
 export declare function moderateDisplayName(name: string): NameRefusal | null;
 export declare function slugBase(login: string): string;
 export declare const suffixedSlug: (base: string, n: number) => string;