@sealkeeper/schema 0.4.6 → 0.4.8

package/dist/credential.js

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { AgentId, Ed25519PublicKey } from './agent-id.js';
-import { Dimension } from './dimensions.js';
+import { AcceptedDimension, Dimension } from './dimensions.js';
 import { Jws } from './envelope.js';
-import { Version } from './events.js';
-import { CountedCounts, Level, StandingCounts } from './standing.js';
+import { StoredVersion } from './events.js';
+import { HANDSHAKE_MAX_CHARS } from './handshake.js';
+import { CountedCounts, CountedCountsV3, Level, StandingCounts, StandingCountsV3, } 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
@@ -29,7 +30,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';
@@ -51,17 +51,14 @@ const Count = z.int().min(0);
 // The version of the SEAL standard this issuer writes, carried as ver.
 export const SEAL_VERSION = 1;
 // Every version a verifier understands. Version 2 is version 1 plus
-// `counted`, the counted evidence the level read (VOU-139). CLIs 0.4.x
-// understand version 1 only and refuse any other ver, so the issuer keeps
-// 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;
+// `counted`, the counted evidence the level read (VOU-139). Version 3 is
+// version 2 plus the posted counts, `fingerprint` and `state`, with the
+// deprecated `version` dropped (VOU-77). CLIs before 0.4.5 understand
+// version 1 only, and CLIs before 0.4.11 do not understand version 3, and
+// each refuses a ver it does not know. So the issuer keeps writing version
+// 1 until every CLI before 0.4.11 is gone. Verifiers accept all three from
+// CLI 0.4.11 on. SEAL standard section 9.
+export const SEAL_VERSIONS = [1, 2, 3];
 // 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
@@ -83,8 +80,16 @@ export const IdentityReference = z.strictObject({
 // 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());
+// payload with a score outside that is malformed. The issuer writes the
+// base dimensions and competence by category only (Dimension). A verifier
+// also accepts competence by task type (AcceptedDimension), the key SEALs
+// carried before RT-3, so a SEAL issued before the change stays valid until
+// it expires and a verifier never has to know which keys an issuer writes
+// today. The API reads its stored SEALs back with the issued shape, so a
+// stored SEAL with a task type key fails that parse and is reissued.
+const Score = z.number().min(0).max(1).nullable();
+const IssuedScores = z.partialRecord(Dimension, Score);
+const VerifiedScores = z.partialRecord(AcceptedDimension, Score);
 // 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.
@@ -99,6 +104,26 @@ export const SEAL_CLOCK_SKEW_SECONDS = 300;
 // and parseSealPayload checks the clock with acceptedIssuer first.
 const IssuedIssuer = z.literal(CREDENTIAL_ISSUER);
 const VerifiedIssuer = z.enum([CREDENTIAL_ISSUER, ...LEGACY_ISSUERS]);
+// The state of a version 3 SEAL, how the agent's current fingerprint stands
+// against the one its level was last confirmed under. The set is closed.
+// matches is the only value the issuer writes until the re-check flow
+// exists. changed and provisional are reserved for it, so a verifier of
+// version 3 already reads them.
+export const SealState = z.enum(['matches', 'changed', 'provisional']);
+// The fingerprint of a version 3 SEAL. hash is SHA-256 over bytes a later
+// change to the standard defines, base64url, and a verifier treats it as
+// opaque until then. at is Unix seconds of when the level was last
+// confirmed under it, never after iat. null when the agent has sent no
+// fingerprint. A 32 byte value in base64url has 43 characters and only
+// some last characters, the rule agent-id.ts uses for a key.
+export const SealFingerprint = z
+    .strictObject({
+    hash: z
+        .string()
+        .regex(/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/, 'SHA-256, base64url'),
+    at: Seconds,
+})
+    .nullable();
 const withinMaxTtl = (c) => c.exp - c.iat <= SEAL_MAX_TTL_SECONDS;
 const MAX_TTL_MESSAGE = 'exp must be at most 24 hours after iat';
 /*
@@ -111,17 +136,17 @@ const MAX_TTL_MESSAGE = 'exp must be at most 24 hours after iat';
  * 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
+const v1Payload = (iss, scores) => z
     .strictObject({
     iss,
     sub: AgentId,
     ver: z.literal(SEAL_VERSION),
     iat: Seconds,
     exp: Seconds,
-    agent_version: Version,
-    version: Version,
+    agent_version: StoredVersion,
+    version: StoredVersion,
     level: Level,
-    scores: Scores,
+    scores,
     counts: StandingCounts,
     operator: z.strictObject({ verified: z.boolean() }),
     identity: z.array(IdentityReference).max(16),
@@ -136,17 +161,17 @@ const v1Payload = (iss) => z
  * counted evidence the level read (CountedCounts). counts stay the raw
  * facts. Each counted value is at most its raw count.
  */
-const v2Payload = (iss) => z
+const v2Payload = (iss, scores) => z
     .strictObject({
     iss,
     sub: AgentId,
     ver: z.literal(2),
     iat: Seconds,
     exp: Seconds,
-    agent_version: Version,
-    version: Version,
+    agent_version: StoredVersion,
+    version: StoredVersion,
     level: Level,
-    scores: Scores,
+    scores,
     counts: StandingCounts,
     counted: CountedCounts,
     operator: z.strictObject({ verified: z.boolean() }),
@@ -160,65 +185,80 @@ 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
+/*
+ * Version 3. Every version 2 field with the same meaning except version,
+ * which is dropped (VOU-77), so agent_version alone names the agent
+ * version. counts gains the three posted counts (StandingCountsV3), counted
+ * gains the counted twins of posted_tasks and posted_confirmed_tasks
+ * (CountedCountsV3), and fingerprint and state are new. Each counted value
+ * is at most its raw count, and fingerprint.at is not after iat. Nothing
+ * issues it yet.
+ */
+const v3Payload = (iss, scores) => z
     .strictObject({
     iss,
     sub: AgentId,
+    ver: z.literal(3),
     iat: Seconds,
     exp: Seconds,
-    version: Version,
-    scores: Scores,
-    counts: z.strictObject({
-        events: Count,
-        verified_tasks: Count,
-        seed_tasks: Count.optional(),
-    }),
+    agent_version: StoredVersion,
+    level: Level,
+    scores,
+    counts: StandingCountsV3,
+    counted: CountedCountsV3,
+    fingerprint: SealFingerprint,
+    state: SealState,
+    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);
-// 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
+    .refine(withinMaxTtl, MAX_TTL_MESSAGE)
+    .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 &&
+    c.counted.posted_tasks <= c.counts.posted_tasks &&
+    c.counted.posted_confirmed_tasks <= c.counts.posted_confirmed_tasks, 'counted must not exceed counts')
+    .refine((c) => c.fingerprint === null || c.fingerprint.at <= c.iat, 'fingerprint.at must not be after iat');
+// The issuer side. iss is CREDENTIAL_ISSUER only, and scores carry
+// competence by category only.
+export const CredentialPayload = v1Payload(IssuedIssuer, IssuedScores);
+export const CredentialPayloadV2 = v2Payload(IssuedIssuer, IssuedScores);
+export const CredentialPayloadV3 = v3Payload(IssuedIssuer, IssuedScores);
+// The verifier side. iss may also be a LEGACY_ISSUERS entry, and scores may
+// also carry competence by task type. 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.
+export const VerifiedCredentialPayload = v1Payload(VerifiedIssuer, VerifiedScores);
+export const VerifiedCredentialPayloadV2 = v2Payload(VerifiedIssuer, VerifiedScores);
+export const VerifiedCredentialPayloadV3 = v3Payload(VerifiedIssuer, VerifiedScores);
+// Any payload a verifier accepts today, version 1, 2 or 3, from the current
+// issuer or a legacy one. Each version has every field of the one before
+// with the same meaning, except version, which version 3 drops. A reader
+// takes the agent version from agent_version, which all three carry.
 export const SealPayload = z.union([
     VerifiedCredentialPayload,
     VerifiedCredentialPayloadV2,
-    VerifiedLegacyCredentialPayload,
+    VerifiedCredentialPayloadV3,
 ]);
-// 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.
+ * after the signature and the issuer check out and before the shape. ver 1,
+ * 2 and 3 (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 +272,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,12 +281,13 @@ 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
+    const ver = hasVer(raw) ? raw.ver : undefined;
+    const parsed = (ver === 3
+        ? VerifiedCredentialPayloadV3
+        : ver === 2
             ? VerifiedCredentialPayloadV2
             : VerifiedCredentialPayload).safeParse(raw);
     return parsed.success
@@ -278,10 +318,17 @@ export const LegacySealExtension = z.strictObject({
     description: z.string().min(1).max(512),
     params: z.strictObject({ credential: Jws }),
 });
+// The current extension may also carry handshake, the agent's signed
+// handshake (VB-6, ./handshake.ts) beside the SEAL, refreshed each time the
+// card is written. A reader takes params loosely, so one that does not know
+// handshake ignores it. The two old URIs carry the SEAL alone.
 export const SealExtension = z.strictObject({
     uri: z.literal(SEAL_EXTENSION_URI),
     description: z.string().min(1).max(512),
-    params: z.strictObject({ credential: Jws }),
+    params: z.strictObject({
+        credential: Jws,
+        handshake: Jws.max(HANDSHAKE_MAX_CHARS).optional(),
+    }),
 });
 export const credentialExtension = (jws) => ({
     uri: CREDENTIAL_EXTENSION_URI,
@@ -293,15 +340,17 @@ export const legacySealExtension = (jws) => ({
     description: EXTENSION_DESCRIPTION,
     params: { credential: jws },
 });
-export const sealExtension = (jws) => ({
+export const sealExtension = (jws, handshake) => ({
     uri: SEAL_EXTENSION_URI,
     description: EXTENSION_DESCRIPTION,
-    params: { credential: jws },
+    params: handshake === undefined
+        ? { credential: jws }
+        : { credential: jws, handshake },
 });
 // The extensions a card carries for one SEAL, in SEAL_EXTENSION_URIS order,
-// the current URI first.
-export const sealExtensions = (jws) => [
-    sealExtension(jws),
+// the current URI first. A handshake goes on the current one only.
+export const sealExtensions = (jws, handshake) => [
+    sealExtension(jws, handshake),
     legacySealExtension(jws),
     credentialExtension(jws),
 ];
@@ -314,9 +363,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/dimensions.d.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { TaskCategory } from './tasks.js';
 export declare const TaskType: z.ZodString;
 export type TaskType = z.infer<typeof TaskType>;
 export declare const BaseDimension: z.ZodEnum<{
@@ -8,14 +9,26 @@ export declare const BaseDimension: z.ZodEnum<{
     safety: "safety";
 }>;
 export type BaseDimension = z.infer<typeof BaseDimension>;
-export declare const CompetenceDimension: z.ZodTemplateLiteral<`competence:${string}`>;
+export declare const CompetenceDimension: z.ZodTemplateLiteral<"competence:code" | "competence:conversation" | "competence:data" | "competence:operations" | "competence:other" | "competence:research" | "competence:writing">;
 export type CompetenceDimension = z.infer<typeof CompetenceDimension>;
+export declare const COMPETENCE_TYPES_MAX = 32;
+export declare const COMPETENCE_DIMENSIONS: readonly CompetenceDimension[];
 export declare const Dimension: z.ZodUnion<readonly [z.ZodEnum<{
     cost_latency: "cost_latency";
     provenance: "provenance";
     reliability: "reliability";
     safety: "safety";
-}>, z.ZodTemplateLiteral<`competence:${string}`>]>;
+}>, z.ZodTemplateLiteral<"competence:code" | "competence:conversation" | "competence:data" | "competence:operations" | "competence:other" | "competence:research" | "competence:writing">]>;
 export type Dimension = z.infer<typeof Dimension>;
-export declare const competence: (taskType: TaskType) => CompetenceDimension;
+export declare const TypeCompetenceDimension: z.ZodTemplateLiteral<`competence:${string}`>;
+export type TypeCompetenceDimension = z.infer<typeof TypeCompetenceDimension>;
+export declare const AcceptedDimension: z.ZodUnion<readonly [z.ZodEnum<{
+    cost_latency: "cost_latency";
+    provenance: "provenance";
+    reliability: "reliability";
+    safety: "safety";
+}>, z.ZodTemplateLiteral<"competence:code" | "competence:conversation" | "competence:data" | "competence:operations" | "competence:other" | "competence:research" | "competence:writing">, z.ZodTemplateLiteral<`competence:${string}`>]>;
+export type AcceptedDimension = z.infer<typeof AcceptedDimension>;
+export declare const competence: (category: TaskCategory) => CompetenceDimension;
+export declare const categoryOf: (dimension: string) => TaskCategory | null;
 export declare const isTrustDimension: (dimension: string) => boolean;

package/dist/dimensions.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { TASK_CATEGORIES, TaskCategory } from './tasks.js';
 export const TaskType = z.string().regex(/^[a-z0-9_-]{1,32}$/);
 export const BaseDimension = z.enum([
     'reliability',
@@ -6,9 +7,54 @@ export const BaseDimension = z.enum([
     'cost_latency',
     'provenance',
 ]);
-export const CompetenceDimension = z.templateLiteral(['competence:', TaskType]);
+/*
+ * Competence rolls up to the task's category (RT-3), one dimension per
+ * category, competence:data and so on. The per task type values stay a
+ * breakdown under the category on the score answer and are never a
+ * dimension of their own.
+ */
+export const CompetenceDimension = z.templateLiteral([
+    'competence:',
+    TaskCategory,
+]);
+// The most task types a competence entry's breakdown lists, the most
+// claimed first, so the answer stays small however many free task types an
+// agent took.
+export const COMPETENCE_TYPES_MAX = 32;
+// The seven competence dimensions in category order, the order every list
+// shows them in.
+export const COMPETENCE_DIMENSIONS = TASK_CATEGORIES.map((c) => CompetenceDimension.parse(`competence:${c}`));
+// What the issuer writes and what a request may name, the base dimensions
+// and the seven competence categories.
 export const Dimension = z.union([BaseDimension, CompetenceDimension]);
-export const competence = (taskType) => CompetenceDimension.parse(`competence:${taskType}`);
+/*
+ * competence:<task_type>, the competence key SEALs carried before RT-3,
+ * when competence was per task type. The issuer no longer writes it. Every category is also a valid task type, so this pattern
+ * takes both kinds of key.
+ */
+export const TypeCompetenceDimension = z.templateLiteral([
+    'competence:',
+    TaskType,
+]);
+/*
+ * Any dimension a reader accepts, issued today or before RT-3. A verifier
+ * reads SEAL scores with it, so a SEAL issued with a task type key stays
+ * valid for the rest of its 24 hours, and so do stored feed items that
+ * name one. Never used for what the issuer writes or a request names.
+ */
+export const AcceptedDimension = z.union([
+    BaseDimension,
+    CompetenceDimension,
+    TypeCompetenceDimension,
+]);
+export const competence = (category) => CompetenceDimension.parse(`competence:${category}`);
+// The category inside a competence dimension, null for any other.
+export const categoryOf = (dimension) => {
+    const parsed = CompetenceDimension.safeParse(dimension);
+    return parsed.success
+        ? parsed.data.slice('competence:'.length)
+        : null;
+};
 // Reliability, safety, provenance and every competence dimension are trust.
 // They need verified work from another operator before they get a value.
 // cost_latency comes from usage events and is information, not trust.

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/fingerprint-conformance.d.ts

@@ -0,0 +1,17 @@
+import type { FingerprintParts } from './fingerprint.js';
+export type PartHashVector = {
+    name: string;
+    sub: string;
+    content: string;
+    hash: string;
+};
+export type FingerprintVector = {
+    name: string;
+    sub: string;
+    parts: FingerprintParts;
+    canonical: string;
+    hash: string;
+};
+export declare const FINGERPRINT_VECTOR_SUB = "11qYAYKxCrfVS_7TyWQHOg7hcvPapiMlrwIaaPcHURo";
+export declare const PART_HASH_VECTORS: readonly PartHashVector[];
+export declare const FINGERPRINT_VECTORS: readonly FingerprintVector[];

package/dist/fingerprint-conformance.js

@@ -0,0 +1,83 @@
+export const FINGERPRINT_VECTOR_SUB = '11qYAYKxCrfVS_7TyWQHOg7hcvPapiMlrwIaaPcHURo';
+const sub = FINGERPRINT_VECTOR_SUB;
+const MODEL = '6soeG-P3CXqRWuQ6H4urtEb45deX7u3mbPL5-qAKQLo';
+const PROMPT = 'mLFX469k6BHZ3-B4a8L_jTSM2ZxJY3u4indqI00En-c';
+const TOOLS = 'otJ7Lv3rmxSYzTJO3fcRNAFpmWHzzovNQQJ7HT9pIO8';
+const FRAMEWORK = 'fZr0sK5GawVx1whZ8jTP7ZEHoteH22nOQS0fH4-UeOw';
+export const PART_HASH_VECTORS = [
+    {
+        name: 'empty content',
+        sub,
+        content: '',
+        hash: '92JJjLzUuso4nM82PbsP-RKqxI1cEBakXLzWFqVoYjg',
+    },
+    { name: 'one model id', sub, content: 'claude-sonnet-4-5', hash: MODEL },
+    {
+        name: 'a prompt',
+        sub,
+        content: 'You are the research agent alice runs.',
+        hash: PROMPT,
+    },
+    {
+        name: 'sorted tool lines',
+        sub,
+        content: 'mcp:github\nmcp:linear\ntool:mcp__github__create_issue',
+        hash: TOOLS,
+    },
+    {
+        name: 'a framework and its version',
+        sub,
+        content: 'claude-code@2.1.283',
+        hash: FRAMEWORK,
+    },
+];
+export const FINGERPRINT_VECTORS = [
+    {
+        name: 'every part declared',
+        sub,
+        parts: {
+            model_set: { hash: MODEL },
+            prompt: { hash: PROMPT },
+            tools: { hash: TOOLS },
+            framework: { hash: FRAMEWORK },
+        },
+        canonical: `${MODEL}\n${PROMPT}\n${TOOLS}\n${FRAMEWORK}`,
+        hash: 'unFXnGMKWNOP4f_NnbearJn0prLlxoGia2LaZcqnzy8',
+    },
+    {
+        name: 'prompt not declared',
+        sub,
+        parts: {
+            model_set: { hash: MODEL },
+            prompt: 'not_declared',
+            tools: { hash: TOOLS },
+            framework: { hash: FRAMEWORK },
+        },
+        canonical: `${MODEL}\nnot_declared\n${TOOLS}\n${FRAMEWORK}`,
+        hash: 'BHAfx6dALmCdt3aXz-g6iAjLLGDurK95DZm15ZjIVZg',
+    },
+    {
+        name: 'tools unstable, prompt not declared',
+        sub,
+        parts: {
+            model_set: { hash: MODEL },
+            prompt: 'not_declared',
+            tools: 'unstable',
+            framework: { hash: FRAMEWORK },
+        },
+        canonical: `${MODEL}\nnot_declared\nunstable\n${FRAMEWORK}`,
+        hash: 'u50ZFfkaGkhaMqciRzxv8meCaFxXycHCr9IasIEPwgk',
+    },
+    {
+        name: 'nothing declared',
+        sub,
+        parts: {
+            model_set: 'not_declared',
+            prompt: 'not_declared',
+            tools: 'not_declared',
+            framework: 'not_declared',
+        },
+        canonical: 'not_declared\nnot_declared\nnot_declared\nnot_declared',
+        hash: 'GupgdwZ9bk92irIz_drScpdSxs6gX2CrSEL9A-ndiHI',
+    },
+];