@sealkeeper/schema 0.0.1 → 0.4.0

package/dist/credential.d.ts

@@ -0,0 +1,392 @@
+import { z } from 'zod';
+export declare const CREDENTIAL_ISSUER = "sealkeeper.run";
+export declare const LEGACY_ISSUERS: readonly ['vouched.run'];
+export declare const LEGACY_ISSUER_UNTIL: number;
+export declare function acceptedIssuer(iss: unknown, nowSeconds: number): boolean;
+export declare const WELL_KNOWN_PATH = "/.well-known/seal.json";
+export declare const LEGACY_WELL_KNOWN_PATH = "/.well-known/vouched.json";
+export declare const WELL_KNOWN_URL = "https://sealkeeper.run/.well-known/seal.json";
+export declare const LEGACY_WELL_KNOWN_URL = "https://vouched.run/.well-known/vouched.json";
+export declare const SEAL_EXTENSION_URI = "https://sealkeeper.run/ext/seal/v1";
+export declare const LEGACY_SEAL_EXTENSION_URI = "https://vouched.run/ext/seal/v1";
+export declare const CREDENTIAL_EXTENSION_URI = "https://vouched.run/ext/credential/v1";
+export declare const LEGACY_SEAL_EXTENSION_URIS: readonly string[];
+export declare const SEAL_EXTENSION_URIS: readonly string[];
+export declare const SEAL_VERSION = 1;
+export declare const LEGACY_UNTIL: number;
+export declare const IdentityKind: z.ZodUnion<readonly [z.ZodEnum<{
+    kya: "kya";
+    oidc: "oidc";
+    saml: "saml";
+    verifiable_credential: "verifiable_credential";
+}>, z.ZodURL]>;
+export type IdentityKind = z.infer<typeof IdentityKind>;
+export declare const IdentityReference: z.ZodObject<{
+    provider: z.ZodURL;
+    kind: z.ZodUnion<readonly [z.ZodEnum<{
+        kya: "kya";
+        oidc: "oidc";
+        saml: "saml";
+        verifiable_credential: "verifiable_credential";
+    }>, z.ZodURL]>;
+    ref: z.ZodString;
+    subject_hash: z.ZodString;
+    attested_at: z.ZodInt;
+    scope: z.ZodEnum<{
+        agent: "agent";
+        operator: "operator";
+    }>;
+}, z.core.$strict>;
+export type IdentityReference = z.infer<typeof IdentityReference>;
+export declare const operatorVerified: (identity: readonly IdentityReference[]) => boolean;
+export declare const SEAL_MAX_TTL_SECONDS: number;
+export declare const SEAL_CLOCK_SKEW_SECONDS = 300;
+export declare const CredentialPayload: z.ZodObject<{
+    iss: z.ZodLiteral<"sealkeeper.run">;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<1>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        distinct_operators: z.ZodInt;
+        safety_incidents_90d: z.ZodInt;
+    }, z.core.$strict>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type CredentialPayload = z.infer<typeof CredentialPayload>;
+export declare const LegacyCredentialPayload: z.ZodObject<{
+    iss: z.ZodLiteral<"sealkeeper.run">;
+    sub: z.ZodString;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    version: z.ZodString;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LegacyCredentialPayload = z.infer<typeof LegacyCredentialPayload>;
+export declare const VerifiedCredentialPayload: z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<1>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        distinct_operators: z.ZodInt;
+        safety_incidents_90d: z.ZodInt;
+    }, z.core.$strict>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type VerifiedCredentialPayload = z.infer<typeof VerifiedCredentialPayload>;
+export declare const VerifiedLegacyCredentialPayload: z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    version: z.ZodString;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type VerifiedLegacyCredentialPayload = z.infer<typeof VerifiedLegacyCredentialPayload>;
+export declare const SealPayload: z.ZodUnion<readonly [z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    ver: z.ZodLiteral<1>;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    agent_version: z.ZodString;
+    version: z.ZodString;
+    level: z.ZodEnum<{
+        bronze: "bronze";
+        gold: "gold";
+        none: "none";
+        silver: "silver";
+    }>;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        history_days: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodInt;
+        server_checked_tasks: z.ZodInt;
+        confirmed_tasks: z.ZodInt;
+        distinct_operators: z.ZodInt;
+        safety_incidents_90d: z.ZodInt;
+    }, z.core.$strict>;
+    operator: z.ZodObject<{
+        verified: z.ZodBoolean;
+    }, z.core.$strict>;
+    identity: z.ZodArray<z.ZodObject<{
+        provider: z.ZodURL;
+        kind: z.ZodUnion<readonly [z.ZodEnum<{
+            kya: "kya";
+            oidc: "oidc";
+            saml: "saml";
+            verifiable_credential: "verifiable_credential";
+        }>, z.ZodURL]>;
+        ref: z.ZodString;
+        subject_hash: z.ZodString;
+        attested_at: z.ZodInt;
+        scope: z.ZodEnum<{
+            agent: "agent";
+            operator: "operator";
+        }>;
+    }, z.core.$strict>>;
+    last_active: z.ZodNullable<z.ZodInt>;
+    dormant_days: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>, z.ZodObject<{
+    iss: z.ZodEnum<{
+        "sealkeeper.run": "sealkeeper.run";
+        "vouched.run": "vouched.run";
+    }>;
+    sub: z.ZodString;
+    iat: z.ZodInt;
+    exp: z.ZodInt;
+    version: z.ZodString;
+    scores: z.ZodRecord<z.ZodUnion<readonly [z.ZodEnum<{
+        cost_latency: "cost_latency";
+        provenance: "provenance";
+        reliability: "reliability";
+        safety: "safety";
+    }>, z.ZodTemplateLiteral<`competence:${string}`>]> & z.core.$partial, z.ZodNullable<z.ZodNumber>>;
+    counts: z.ZodObject<{
+        events: z.ZodInt;
+        verified_tasks: z.ZodInt;
+        seed_tasks: z.ZodOptional<z.ZodInt>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+export type SealPayload = z.infer<typeof SealPayload>;
+export declare const isSealV1: (p: SealPayload) => p is VerifiedCredentialPayload;
+export declare function sealVersionProblem(raw: unknown, nowSeconds: number): 'unsupported_version' | null;
+export declare function sealIatProblem(iat: number, nowSeconds: number): 'not_yet_valid' | null;
+export type SealPayloadResult = {
+    ok: true;
+    payload: SealPayload;
+} | {
+    ok: false;
+    reason: 'wrong_issuer' | 'unsupported_version' | 'malformed';
+};
+export declare function parseSealPayload(raw: unknown, nowSeconds: number): SealPayloadResult;
+export declare const WellKnownKey: z.ZodObject<{
+    kid: z.ZodString;
+    kty: z.ZodLiteral<"OKP">;
+    crv: z.ZodLiteral<"Ed25519">;
+    alg: z.ZodLiteral<"EdDSA">;
+    x: z.ZodString;
+}, z.core.$strict>;
+export type WellKnownKey = z.infer<typeof WellKnownKey>;
+export declare const WellKnown: z.ZodObject<{
+    keys: z.ZodArray<z.ZodObject<{
+        kid: z.ZodString;
+        kty: z.ZodLiteral<"OKP">;
+        crv: z.ZodLiteral<"Ed25519">;
+        alg: z.ZodLiteral<"EdDSA">;
+        x: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type WellKnown = z.infer<typeof WellKnown>;
+export declare const CredentialExtension: z.ZodObject<{
+    uri: z.ZodLiteral<"https://vouched.run/ext/credential/v1">;
+    description: z.ZodString;
+    params: z.ZodObject<{
+        credential: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CredentialExtension = z.infer<typeof CredentialExtension>;
+export declare const LegacySealExtension: z.ZodObject<{
+    uri: z.ZodLiteral<"https://vouched.run/ext/seal/v1">;
+    description: z.ZodString;
+    params: z.ZodObject<{
+        credential: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LegacySealExtension = z.infer<typeof LegacySealExtension>;
+export declare const SealExtension: z.ZodObject<{
+    uri: z.ZodLiteral<"https://sealkeeper.run/ext/seal/v1">;
+    description: z.ZodString;
+    params: z.ZodObject<{
+        credential: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SealExtension = z.infer<typeof SealExtension>;
+export declare const credentialExtension: (jws: string) => CredentialExtension;
+export declare const legacySealExtension: (jws: string) => LegacySealExtension;
+export declare const sealExtension: (jws: string) => SealExtension;
+export declare const sealExtensions: (jws: string) => ({
+    uri: "https://vouched.run/ext/credential/v1";
+    description: string;
+    params: {
+        credential: string;
+    };
+} | {
+    uri: "https://vouched.run/ext/seal/v1";
+    description: string;
+    params: {
+        credential: string;
+    };
+} | {
+    uri: "https://sealkeeper.run/ext/seal/v1";
+    description: string;
+    params: {
+        credential: string;
+    };
+})[];
+export declare const A2A_PROTOCOL_VERSION = "0.3.0";
+export declare const AgentSkill: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+    examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type AgentSkill = z.infer<typeof AgentSkill>;
+export declare const AgentCard: z.ZodObject<{
+    protocolVersion: z.ZodLiteral<"0.3.0">;
+    name: z.ZodString;
+    description: z.ZodString;
+    url: z.ZodOptional<z.ZodURL>;
+    version: z.ZodString;
+    capabilities: z.ZodObject<{
+        extensions: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            uri: z.ZodLiteral<"https://sealkeeper.run/ext/seal/v1">;
+            description: z.ZodString;
+            params: z.ZodObject<{
+                credential: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            uri: z.ZodLiteral<"https://vouched.run/ext/seal/v1">;
+            description: z.ZodString;
+            params: z.ZodObject<{
+                credential: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            uri: z.ZodLiteral<"https://vouched.run/ext/credential/v1">;
+            description: z.ZodString;
+            params: z.ZodObject<{
+                credential: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>;
+    skills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+        examples: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    defaultInputModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    defaultOutputModes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export type AgentCard = z.infer<typeof AgentCard>;
+export type AgentCardInput = z.input<typeof AgentCard>;

package/dist/credential.js

@@ -0,0 +1,287 @@
+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 { Level, StandingCounts } from './standing.js';
+// The issuer every SEAL carries as iss from the SealKeeper cutover on.
+export const CREDENTIAL_ISSUER = 'sealkeeper.run';
+// Issuers a verifier still accepts for a while after the cutover. A SEAL
+// lives at most 24 hours, so one issued as vouched.run just before the
+// cutover has expired well before LEGACY_ISSUER_UNTIL. From then on only
+// CREDENTIAL_ISSUER is accepted.
+export const LEGACY_ISSUERS = ['vouched.run'];
+// Unix seconds, the first second a LEGACY_ISSUERS entry is no longer
+// accepted. 2 October 2026 00:00 UTC.
+export const LEGACY_ISSUER_UNTIL = Date.UTC(2026, 9, 2) / 1000;
+// Whether a verifier accepts iss at nowSeconds. CREDENTIAL_ISSUER always, a
+// legacy issuer only before LEGACY_ISSUER_UNTIL, anything else never.
+export function acceptedIssuer(iss, nowSeconds) {
+    if (iss === CREDENTIAL_ISSUER)
+        return true;
+    return (typeof iss === 'string' &&
+        LEGACY_ISSUERS.includes(iss) &&
+        nowSeconds < LEGACY_ISSUER_UNTIL);
+}
+// The path of the keys document, on the issuer's own domain. It is product
+// neutral so another issuer can serve the same path. The old path is served
+// beside it for one release.
+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';
+export const LEGACY_SEAL_EXTENSION_URI = 'https://vouched.run/ext/seal/v1';
+// The first card extension URI, kept under its old name so callers compile.
+export const CREDENTIAL_EXTENSION_URI = 'https://vouched.run/ext/credential/v1';
+export const LEGACY_SEAL_EXTENSION_URIS = [
+    LEGACY_SEAL_EXTENSION_URI,
+    CREDENTIAL_EXTENSION_URI,
+];
+// Every URI a SEAL extension may carry, the current one first. A card
+// rebuilt with a fresh SEAL drops extensions with any of these first.
+export const SEAL_EXTENSION_URIS = [
+    SEAL_EXTENSION_URI,
+    ...LEGACY_SEAL_EXTENSION_URIS,
+];
+const Seconds = z.int().min(0);
+const Count = z.int().min(0);
+// The version of the SEAL standard this issuer writes, carried as ver.
+export const SEAL_VERSION = 1;
+// 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
+// else. subject_hash is SHA-256 of the provider's subject id, base64url.
+export const IdentityKind = z.union([
+    z.enum(['oidc', 'saml', 'verifiable_credential', 'kya']),
+    z.url().max(512),
+]);
+export const IdentityReference = z.strictObject({
+    provider: z.url().max(512),
+    kind: IdentityKind,
+    ref: z.string().min(1).max(512),
+    subject_hash: z.string().regex(/^[A-Za-z0-9_-]{43}$/, 'SHA-256, base64url'),
+    attested_at: Seconds,
+    scope: z.enum(['operator', 'agent']),
+});
+// operator.verified in the SEAL. True when an operator scoped reference is
+// held. The issuer drops a reference when its attestation expires or is
+// revoked, so every reference it still holds is current.
+export const operatorVerified = (identity) => identity.some((r) => r.scope === 'operator');
+// Each score is 0 to 1, or null when unearned (standard section 2). A
+// payload with a score outside that is malformed.
+const Scores = z.partialRecord(Dimension, z.number().min(0).max(1).nullable());
+// A SEAL lives at most 24 hours from issue, standard section 2. The issuer's
+// CREDENTIAL_TTL_HOURS may not go above it, and a payload whose exp is
+// further from its iat is malformed.
+export const SEAL_MAX_TTL_SECONDS = 24 * 3600;
+// How far ahead of the verifier's clock iat may be before a SEAL is not yet
+// valid. Five minutes covers clock drift between issuer and verifier.
+export const SEAL_CLOCK_SKEW_SECONDS = 300;
+// iss on the issuer side is CREDENTIAL_ISSUER and nothing else. The API
+// writes it and reads its stored SEALs back with CredentialPayload, so a
+// stored SEAL with a legacy issuer fails that parse and is reissued. Only
+// a verifier accepts a legacy issuer, through the Verified shapes below,
+// and parseSealPayload checks the clock with acceptedIssuer first.
+const IssuedIssuer = z.literal(CREDENTIAL_ISSUER);
+const VerifiedIssuer = z.enum([CREDENTIAL_ISSUER, ...LEGACY_ISSUERS]);
+const withinMaxTtl = (c) => c.exp - c.iat <= SEAL_MAX_TTL_SECONDS;
+const MAX_TTL_MESSAGE = 'exp must be at most 24 hours after iat';
+/*
+ * The SEAL payload, version 1 of the SEAL standard (section 2). Strict, it
+ * is what the API issues. version is agent_version under its old name, sent
+ * for one release so a verifier written against the old shape keeps
+ * 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.
+ */
+const v1Payload = (iss) => z
+    .strictObject({
+    iss,
+    sub: AgentId,
+    ver: z.literal(SEAL_VERSION),
+    iat: Seconds,
+    exp: Seconds,
+    agent_version: Version,
+    version: Version,
+    level: Level,
+    scores: Scores,
+    counts: StandingCounts,
+    operator: z.strictObject({ verified: z.boolean() }),
+    identity: z.array(IdentityReference).max(16),
+    last_active: Seconds.nullable(),
+    dormant_days: Count.nullable(),
+})
+    .refine((c) => c.exp > c.iat, 'exp must be after iat')
+    .refine(withinMaxTtl, MAX_TTL_MESSAGE)
+    .refine((c) => c.version === c.agent_version, 'version must equal agent_version');
+// 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 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 VerifiedLegacyCredentialPayload = legacyPayload(VerifiedIssuer);
+// Any payload a verifier accepts today, version 1 or legacy, from the
+// current issuer or a legacy one.
+export const SealPayload = z.union([
+    VerifiedCredentialPayload,
+    VerifiedLegacyCredentialPayload,
+]);
+// A version 1 payload carries every legacy field too, so the guard is on
+// version 1, the narrower of the two. Its false branch is the legacy shape.
+export const isSealV1 = (p) => 'ver' in p;
+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
+ * is 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.
+ */
+export function sealVersionProblem(raw, nowSeconds) {
+    if (typeof raw !== 'object' || raw === null)
+        return null;
+    if (hasVer(raw)) {
+        return raw.ver === SEAL_VERSION ? null : 'unsupported_version';
+    }
+    return nowSeconds < LEGACY_UNTIL ? null : 'unsupported_version';
+}
+/*
+ * The iat half of step 4 of the standard, section 3. "Check exp is in the
+ * future and iat is not." Every verifier calls this after the shape parse
+ * and right after its expiry check, in the standard's order, exp first and
+ * then iat. A SEAL whose iat is more than SEAL_CLOCK_SKEW_SECONDS ahead of
+ * the verifier's clock is not_yet_valid. Within the skew it is accepted, so
+ * a verifier whose clock runs a little slow does not break fresh SEALs.
+ */
+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.
+export function parseSealPayload(raw, nowSeconds) {
+    const iss = typeof raw === 'object' && raw !== null && 'iss' in raw
+        ? raw.iss
+        : undefined;
+    if (!acceptedIssuer(iss, nowSeconds)) {
+        return { ok: false, reason: 'wrong_issuer' };
+    }
+    const problem = sealVersionProblem(raw, nowSeconds);
+    if (problem)
+        return { ok: false, reason: problem };
+    const parsed = (hasVer(raw) ? VerifiedCredentialPayload : VerifiedLegacyCredentialPayload).safeParse(raw);
+    return parsed.success
+        ? { ok: true, payload: parsed.data }
+        : { ok: false, reason: 'malformed' };
+}
+export const WellKnownKey = z.strictObject({
+    kid: z.string().min(1).max(128),
+    kty: z.literal('OKP'),
+    crv: z.literal('Ed25519'),
+    alg: z.literal('EdDSA'),
+    x: Ed25519PublicKey,
+});
+export const WellKnown = z.strictObject({
+    keys: z.array(WellKnownKey).min(1).max(16),
+});
+const EXTENSION_DESCRIPTION = `SealKeeper SEAL, Signed Evidence of Agent Legitimacy. JWS compact, EdDSA, verify offline with the keys at ${WELL_KNOWN_URL}`;
+// Every extension carries the same SEAL under the same params key. A card
+// has the current one and the two old ones for one release, then only the
+// current one (VOU-77).
+export const CredentialExtension = z.strictObject({
+    uri: z.literal(CREDENTIAL_EXTENSION_URI),
+    description: z.string().min(1).max(512),
+    params: z.strictObject({ credential: Jws }),
+});
+export const LegacySealExtension = z.strictObject({
+    uri: z.literal(LEGACY_SEAL_EXTENSION_URI),
+    description: z.string().min(1).max(512),
+    params: z.strictObject({ credential: Jws }),
+});
+export const SealExtension = z.strictObject({
+    uri: z.literal(SEAL_EXTENSION_URI),
+    description: z.string().min(1).max(512),
+    params: z.strictObject({ credential: Jws }),
+});
+export const credentialExtension = (jws) => ({
+    uri: CREDENTIAL_EXTENSION_URI,
+    description: EXTENSION_DESCRIPTION,
+    params: { credential: jws },
+});
+export const legacySealExtension = (jws) => ({
+    uri: LEGACY_SEAL_EXTENSION_URI,
+    description: EXTENSION_DESCRIPTION,
+    params: { credential: jws },
+});
+export const sealExtension = (jws) => ({
+    uri: SEAL_EXTENSION_URI,
+    description: EXTENSION_DESCRIPTION,
+    params: { credential: jws },
+});
+// The extensions a card carries for one SEAL, in SEAL_EXTENSION_URIS order,
+// the current URI first.
+export const sealExtensions = (jws) => [
+    sealExtension(jws),
+    legacySealExtension(jws),
+    credentialExtension(jws),
+];
+export const A2A_PROTOCOL_VERSION = '0.3.0';
+export const AgentSkill = z.strictObject({
+    id: z.string().min(1).max(128),
+    name: z.string().min(1).max(128),
+    description: z.string().min(1).max(1024),
+    tags: z.array(z.string().min(1).max(64)).max(32),
+    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.
+export const AgentCard = z.strictObject({
+    protocolVersion: z.literal(A2A_PROTOCOL_VERSION),
+    name: z.string().min(1).max(128),
+    description: z.string().min(1).max(1024),
+    url: z.url({ protocol: /^https$/ }).optional(),
+    version: z.string().min(1).max(64),
+    capabilities: z.strictObject({
+        extensions: z
+            .array(z.union([SealExtension, LegacySealExtension, CredentialExtension]))
+            .max(8),
+    }),
+    skills: z.array(AgentSkill).max(64),
+    defaultInputModes: Modes,
+    defaultOutputModes: Modes,
+});