@tiertwo/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tier Two
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,131 @@
+# @tiertwo/sdk
+
+Verify **Tier Two** verified-human signup tokens on your server in one call.
+
+When an AI agent (Claude Code, Codex, …) creates an account on your site as a real,
+[Tier Two](https://trytiertwo.com)-verified human, it presents a short-lived
+`Authorization: Bearer <jwt>`. This SDK verifies that token **offline** against Tier
+Two's published JWKS — no API key, no network call to us on the hot path beyond
+fetching (and caching) the public keys.
+
+```bash
+npm install @tiertwo/sdk      # or pnpm add / yarn add
+```
+
+## Usage
+
+```ts
+import { verifyHumanSignup } from "@tiertwo/sdk";
+
+// Express / Next route handler / any server with a Request-like object.
+app.post("/signup", async (req, res) => {
+  const result = await verifyHumanSignup(req, { domain: "acme.com" });
+
+  if (!result.valid) {
+    // Fail closed — never create the account on a failed check.
+    return res.status(403).json({ ok: false, reason: result.reason });
+  }
+
+  // A verified human authorized this signup for acme.com → create the account.
+  res.status(201).json({
+    sub: result.sub, // stable, pairwise id for (this human, your domain)
+    country: result.country, // ISO-3166 alpha-2, or null
+    age_over_18: result.age_over_18,
+  });
+});
+```
+
+`req` may be a Web `Request`, a Node `IncomingMessage`, or a raw token string — the SDK
+extracts the bearer token for you.
+
+## What gets verified
+
+`verifyHumanSignup` checks, against the issuer's JWKS:
+
+- **signature** (EdDSA only — `alg:none` and HS-key-confusion are rejected),
+- **`iss`** equals your configured issuer (defaults to `https://trytiertwo.com`),
+- **`aud`** equals your `domain`,
+- **`action`** is in the closed enum (MVP: `create_account`),
+- **`exp` / `nbf`** within a ±30s clock-skew tolerance,
+- **`verified_human === true`**.
+
+## Result shape
+
+`verifyHumanSignup` returns a discriminated union — narrow on `valid`. It **never
+throws**; every error path returns `{ valid: false, reason }` so you always fail closed.
+
+```ts
+type VerifyResult =
+  | {
+      valid: true;
+      verified: true;
+      country: string | null; // ISO-3166 alpha-2
+      age_over_18: boolean;
+      sub: string; // pairwise/directed subject — stable per (user, your domain)
+      deviceId: string; // the device that produced the request
+      jti: string; // unique token id — dedupe it (see below)
+      action: "create_account";
+    }
+  | { valid: false; reason: FailureReason };
+```
+
+`reason` is one of: `no_token`, `no_domain`, `malformed`, `bad_signature`, `expired`,
+`not_yet_valid`, `wrong_issuer`, `wrong_audience`, `wrong_action`, `not_verified`,
+`jwks_unreachable`. A JWKS fetch failure surfaces as `jwks_unreachable` — still a
+failure, so you stay closed.
+
+## Configuration
+
+Options can be passed inline or sourced from the environment so the call is argument-free:
+
+| Option     | Env var               | Default                     |
+| ---------- | --------------------- | --------------------------- |
+| `domain`   | `TIERTWO_DOMAIN`      | — (required)                |
+| `issuer`   | `TIERTWO_ISSUER_URL`  | `https://trytiertwo.com`    |
+| `jwksUrl`  | —                     | `${issuer}/.well-known/jwks.json` |
+| `jwks`     | —                     | a memoized remote JWKS set  |
+
+```ts
+// With TIERTWO_DOMAIN set, the call needs no arguments:
+const result = await verifyHumanSignup(req);
+```
+
+For local development against a self-hosted issuer, set
+`TIERTWO_ISSUER_URL=http://localhost:3000`. The `jwks` option accepts a `jose` key
+resolver (e.g. `createLocalJWKSet`) to verify fully offline in tests.
+
+## Replay dedupe (recommended)
+
+The token is single-purpose, domain+action-bound, and lives ≤5 minutes — but you
+should also reject a `jti` you've already honored, so the same token can't create two
+accounts inside its window. The SDK ships a small helper; wire it to your own store:
+
+```ts
+import { verifyHumanSignup, hasSeenJti, MemoryJtiStore } from "@tiertwo/sdk";
+
+// Use a shared store (Redis/DB) in production so dedupe holds across replicas.
+// MemoryJtiStore is for single-process demos/tests.
+const jtiStore = new MemoryJtiStore();
+
+const result = await verifyHumanSignup(req, { domain: "acme.com" });
+if (!result.valid) return reject(result.reason);
+
+if (await hasSeenJti(result.jti, jtiStore)) {
+  return reject("replayed"); // already used this token
+}
+// ...create the account.
+```
+
+`JtiStore` is just `{ has(jti), add(jti, expiresAtMs?) }` — back it with Redis `SET …
+EX`, a unique DB column, etc. `hasSeenJti` records the `jti` with a default 5-minute
+TTL (the token lifetime).
+
+## Notes
+
+- **Offline by design.** Verification trusts exactly one thing: the issuer JWKS.
+  There is no token-introspection call back to Tier Two.
+- **Fail closed, always.** Treat any `{ valid: false }` — including
+  `jwks_unreachable` — as "do not create the account."
+
+See [`docs/ARCHITECTURE.md`](https://github.com/Jordan-M/verified-human/blob/master/docs/ARCHITECTURE.md)
+§12 for the full contract.

package/dist/extract.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the JWT, or undefined if none is present.
+ * - A raw token string (already extracted by the caller) is passed through,
+ *   with or without a `Bearer` prefix.
+ * - From a request object we read `Authorization: Bearer <jwt>` and require the
+ *   scheme (a schemeless header value is non-standard → rejected).
+ */
+export declare function extractBearer(input: unknown): string | undefined;

package/dist/extract.js

@@ -0,0 +1,50 @@
+// Pull the bearer token out of whatever the merchant's framework hands us:
+// a Web `Request` (Next App Router, Hono, Deno), a Node `IncomingMessage`
+// (Express/raw http — `req.headers.authorization`), or a raw token string.
+// Framework-agnostic by design (ARCHITECTURE §12).
+function readAuthorization(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const headers = input.headers;
+    if (!headers)
+        return undefined;
+    // Web `Headers` exposes a case-insensitive `.get()`.
+    if (typeof headers.get === "function") {
+        return headers.get("authorization") ?? undefined;
+    }
+    // Node lowercases header keys; tolerate arrays just in case.
+    const raw = headers["authorization"];
+    return Array.isArray(raw) ? raw[0] : raw;
+}
+/**
+ * Returns the JWT, or undefined if none is present.
+ * - A raw token string (already extracted by the caller) is passed through,
+ *   with or without a `Bearer` prefix.
+ * - From a request object we read `Authorization: Bearer <jwt>` and require the
+ *   scheme (a schemeless header value is non-standard → rejected).
+ */
+export function extractBearer(input) {
+    if (typeof input === "string") {
+        return parseAuthorization(input, /* allowBare */ true);
+    }
+    const header = readAuthorization(input);
+    if (header === undefined)
+        return undefined;
+    return parseAuthorization(header, /* allowBare */ false);
+}
+function parseAuthorization(value, allowBare) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const match = /^Bearer\s+(.+)$/i.exec(trimmed);
+    if (match)
+        return match[1].trim() || undefined;
+    // Begins with the scheme word but has no token after it → malformed.
+    if (/^Bearer\b/i.test(trimmed))
+        return undefined;
+    // A bare, schemeless token is accepted only from a raw string the caller
+    // passed directly, and only when it isn't itself a (wrong-scheme) header.
+    if (allowBare && !/\s/.test(trimmed))
+        return trimmed;
+    return undefined;
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { verifyHumanAction, verifyHumanSignup } from "./verify.js";
+export { hasSeenJti, MemoryJtiStore, type JtiStore } from "./jti.js";
+export type { VerifyResult, VerifySuccess, VerifyFailure, VerifyOptions, VerifyActionOptions, FailureReason, } from "./types.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+// @tiertwo/sdk — the merchant/enforcer's one-verb verification of a Tier Two token.
+// `verifyHumanAction` verifies a short-lived EdDSA JWT against our published JWKS and
+// asserts the expected action (+ optional resource + tier); `verifyHumanSignup` is
+// the consumer-signup convenience. Both fail closed. See docs/ARCHITECTURE.md §12,
+// §18.6, §18.7.
+export { verifyHumanAction, verifyHumanSignup } from "./verify.js";
+export { hasSeenJti, MemoryJtiStore } from "./jti.js";

package/dist/jti.d.ts

@@ -0,0 +1,20 @@
+/** Merchant-supplied store. `add` should set its own TTL (token lives ≤5 min). */
+export interface JtiStore {
+    has(jti: string): boolean | Promise<boolean>;
+    add(jti: string, expiresAtMs?: number): void | Promise<void>;
+}
+/**
+ * Returns true if this `jti` was already seen (caller should reject); otherwise
+ * records it and returns false. `ttlMs` defaults to the 5-min token lifetime.
+ */
+export declare function hasSeenJti(jti: string, store: JtiStore, ttlMs?: number): Promise<boolean>;
+/**
+ * Reference in-memory JtiStore for tests/single-process demos. Production should
+ * use a shared store (Redis/DB) so dedupe holds across replicas. Prunes lazily.
+ */
+export declare class MemoryJtiStore implements JtiStore {
+    private readonly seen;
+    has(jti: string): boolean;
+    add(jti: string, expiresAtMs?: number): void;
+    private prune;
+}

package/dist/jti.js

@@ -0,0 +1,43 @@
+// Optional replay-dedupe helper (ARCHITECTURE §18.6). The JWT is already
+// single-purpose, domain+action-bound, and 5-min TTL — but a merchant SHOULD
+// also reject a `jti` they've already honored, so the same token can't create
+// two accounts within its window. We never touch the merchant's store for them;
+// they wire `hasSeenJti` to their own DB/Redis via the JtiStore interface.
+/**
+ * Returns true if this `jti` was already seen (caller should reject); otherwise
+ * records it and returns false. `ttlMs` defaults to the 5-min token lifetime.
+ */
+export async function hasSeenJti(jti, store, ttlMs = 300_000) {
+    if (await store.has(jti))
+        return true;
+    await store.add(jti, Date.now() + ttlMs);
+    return false;
+}
+/**
+ * Reference in-memory JtiStore for tests/single-process demos. Production should
+ * use a shared store (Redis/DB) so dedupe holds across replicas. Prunes lazily.
+ */
+export class MemoryJtiStore {
+    seen = new Map();
+    has(jti) {
+        const expiresAt = this.seen.get(jti);
+        if (expiresAt === undefined)
+            return false;
+        if (expiresAt <= Date.now()) {
+            this.seen.delete(jti);
+            return false;
+        }
+        return true;
+    }
+    add(jti, expiresAtMs = Date.now() + 300_000) {
+        this.prune();
+        this.seen.set(jti, expiresAtMs);
+    }
+    prune() {
+        const now = Date.now();
+        for (const [jti, expiresAt] of this.seen) {
+            if (expiresAt <= now)
+                this.seen.delete(jti);
+        }
+    }
+}

package/dist/jwks.d.ts

@@ -0,0 +1,4 @@
+import type { KeyResolver } from "./types.js";
+export declare function remoteJwks(jwksUrl: string): KeyResolver;
+/** Test-only: drop the memoized resolvers so a fresh URL/key set is used. */
+export declare function clearJwksCache(): void;

package/dist/jwks.js

@@ -0,0 +1,19 @@
+// Memoized issuer-JWKS resolver. `createRemoteJWKSet` returns a key-resolving
+// function with its own internal cache + auto-refresh-on-unknown-`kid`; we cache
+// that function per URL so a long-running merchant process reuses the cache
+// instead of re-fetching on every signup. Keeps our uptime off the merchant's
+// critical path (ARCHITECTURE §18.7).
+import { createRemoteJWKSet } from "jose";
+const cache = new Map();
+export function remoteJwks(jwksUrl) {
+    let resolver = cache.get(jwksUrl);
+    if (!resolver) {
+        resolver = createRemoteJWKSet(new URL(jwksUrl));
+        cache.set(jwksUrl, resolver);
+    }
+    return resolver;
+}
+/** Test-only: drop the memoized resolvers so a fresh URL/key set is used. */
+export function clearJwksCache() {
+    cache.clear();
+}

package/dist/types.d.ts

@@ -0,0 +1,72 @@
+import type { JWTVerifyGetKey } from "jose";
+import type { Action, AuthLevel, Resource } from "@tiertwo/shared";
+/**
+ * Why a verification failed. Returned (never thrown) so the merchant fails closed
+ * but can still log/debug. None of these should be treated as success.
+ */
+export type FailureReason = "no_token" | "no_domain" | "malformed" | "bad_signature" | "expired" | "not_yet_valid" | "wrong_issuer" | "wrong_audience" | "wrong_action" | "wrong_resource" | "insufficient_auth_level" | "jwks_unreachable";
+/** Successful verification — exactly the §12 shape the merchant consumes. */
+export type VerifySuccess = {
+    valid: true;
+    /** The `verified_human` claim (derived: auth_level === "identity_proofed"). */
+    verified: boolean;
+    /** ISO-3166 alpha-2, or null when unknown. */
+    country: string | null;
+    age_over_18: boolean;
+    /** Pairwise/directed subject — stable per (user, this merchant). (§18.3) */
+    sub: string;
+    /** The device that produced the request (`device_id` claim). */
+    deviceId: string;
+    /** Unique token id — merchant SHOULD dedupe via hasSeenJti (§18.6). */
+    jti: string;
+    /** The bound action (a validated string, e.g. "create_account", "deploy"). */
+    action: Action;
+    /** The bound resource scope, or null for an unscoped action. */
+    resource: string | null;
+    /** The assurance tier the token was minted at. */
+    authLevel: AuthLevel;
+};
+export type VerifyFailure = {
+    valid: false;
+    reason: FailureReason;
+};
+/** Discriminated union — narrow on `valid`. */
+export type VerifyResult = VerifySuccess | VerifyFailure;
+/** A `jose` key resolver, e.g. the function returned by createRemoteJWKSet. */
+export type KeyResolver = JWTVerifyGetKey;
+export type VerifyOptions = {
+    /**
+     * Merchant domain the token must be bound to (`aud`). Defaults to the
+     * `TIERTWO_DOMAIN` env var so the call can be argument-free.
+     */
+    domain?: string;
+    /**
+     * Issuer base URL — drives both the `iss` claim check and the JWKS location.
+     * Defaults to `TIERTWO_ISSUER_URL` env var, then `https://trytiertwo.com`.
+     */
+    issuer?: string;
+    /**
+     * Full JWKS URL. Defaults to `${issuer}/.well-known/jwks.json`.
+     */
+    jwksUrl?: string;
+    /**
+     * Advanced/testing: inject a `jose` key resolver (e.g. createLocalJWKSet) to
+     * verify fully offline. When set, `jwksUrl` is ignored.
+     */
+    jwks?: KeyResolver;
+};
+/** Options for `verifyHumanAction` — a VerifyOptions plus the expectations to enforce. */
+export type VerifyActionOptions = VerifyOptions & {
+    /** The action the token MUST carry (exact match) — else `wrong_action`. */
+    action: Action;
+    /**
+     * If set, the token's `resource` must equal this exactly — else `wrong_resource`.
+     * Omit to accept any resource (including none).
+     */
+    expectedResource?: Resource;
+    /**
+     * If set, the token's `auth_level` must be at least this tier — else
+     * `insufficient_auth_level`. Omit to accept any tier.
+     */
+    requiredAuthLevel?: AuthLevel;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/verify.d.ts

@@ -0,0 +1,16 @@
+import type { VerifyActionOptions, VerifyOptions, VerifyResult } from "./types.js";
+/**
+ * Verify a request carrying `Authorization: Bearer <jwt>` (or a raw token) and
+ * assert it authorizes a specific action (with optional resource + minimum tier).
+ *
+ * @param req  Web `Request`, Node `IncomingMessage`, or a raw token string.
+ * @param opts `{ action, expectedResource?, requiredAuthLevel?, domain, issuer,
+ *             jwksUrl, jwks }` — `domain`/`issuer` default from `TIERTWO_DOMAIN` /
+ *             `TIERTWO_ISSUER_URL`.
+ */
+export declare function verifyHumanAction(req: unknown, opts: VerifyActionOptions): Promise<VerifyResult>;
+/**
+ * Consumer-signup convenience: verify a token authorizes `create_account` at the
+ * identity-proofed tier. One line over `verifyHumanAction`.
+ */
+export declare function verifyHumanSignup(req: unknown, opts?: VerifyOptions): Promise<VerifyResult>;

package/dist/verify.js

@@ -0,0 +1,135 @@
+// verifyHumanAction — the merchant/enforcer's one-verb integration (ARCHITECTURE §12).
+// Verifies a short-lived EdDSA JWT minted by the Tier Two issuer against our
+// published JWKS, enforces the expected action (and optional resource + assurance
+// tier), and fails CLOSED on every error path: any problem returns
+// { valid: false, reason } — never a throw a caller might treat as success.
+import { jwtVerify, errors } from "jose";
+import { AUTH_LEVELS, meetsAuthLevel } from "@tiertwo/shared";
+import { extractBearer } from "./extract.js";
+import { remoteJwks } from "./jwks.js";
+const DEFAULT_ISSUER = "https://trytiertwo.com";
+const CLOCK_SKEW_SECONDS = 30; // ±30s tolerance (§18.6)
+function fail(reason) {
+    return { valid: false, reason };
+}
+/**
+ * Verify a request carrying `Authorization: Bearer <jwt>` (or a raw token) and
+ * assert it authorizes a specific action (with optional resource + minimum tier).
+ *
+ * @param req  Web `Request`, Node `IncomingMessage`, or a raw token string.
+ * @param opts `{ action, expectedResource?, requiredAuthLevel?, domain, issuer,
+ *             jwksUrl, jwks }` — `domain`/`issuer` default from `TIERTWO_DOMAIN` /
+ *             `TIERTWO_ISSUER_URL`.
+ */
+export async function verifyHumanAction(req, opts) {
+    try {
+        const token = extractBearer(req);
+        if (!token)
+            return fail("no_token");
+        const domain = opts.domain ?? process.env.TIERTWO_DOMAIN;
+        if (!domain)
+            return fail("no_domain");
+        const issuer = opts.issuer ?? process.env.TIERTWO_ISSUER_URL ?? DEFAULT_ISSUER;
+        const keyResolver = opts.jwks ??
+            remoteJwks(opts.jwksUrl ?? `${issuer.replace(/\/$/, "")}/.well-known/jwks.json`);
+        let payload;
+        try {
+            ({ payload } = await jwtVerify(token, keyResolver, {
+                issuer, // enforces `iss`
+                audience: domain, // enforces `aud === domain`
+                algorithms: ["EdDSA"], // blocks alg:none + HS256 key-confusion
+                clockTolerance: CLOCK_SKEW_SECONDS, // covers exp/nbf/iat skew
+            }));
+        }
+        catch (err) {
+            return fail(mapError(err));
+        }
+        // Claims jose can't validate for us: exact action, optional resource + tier.
+        const action = payload.action;
+        if (typeof action !== "string" || action !== opts.action) {
+            return fail("wrong_action");
+        }
+        const resource = typeof payload.resource === "string" ? payload.resource : null;
+        if (opts.expectedResource !== undefined && resource !== opts.expectedResource) {
+            return fail("wrong_resource");
+        }
+        const authLevel = payload.auth_level;
+        if (typeof authLevel !== "string" ||
+            !AUTH_LEVELS.includes(authLevel)) {
+            return fail("malformed");
+        }
+        if (opts.requiredAuthLevel !== undefined &&
+            !meetsAuthLevel(authLevel, opts.requiredAuthLevel)) {
+            return fail("insufficient_auth_level");
+        }
+        // Required, well-typed identity fields.
+        const { sub, jti } = payload;
+        const deviceId = payload.device_id;
+        if (typeof sub !== "string" ||
+            typeof jti !== "string" ||
+            typeof deviceId !== "string") {
+            return fail("malformed");
+        }
+        return {
+            valid: true,
+            verified: payload.verified_human === true,
+            country: typeof payload.country === "string" ? payload.country : null,
+            age_over_18: payload.age_over_18 === true,
+            sub,
+            deviceId,
+            jti,
+            action: action,
+            resource,
+            authLevel: authLevel,
+        };
+    }
+    catch {
+        // Absolute backstop — verification must never throw.
+        return fail("bad_signature");
+    }
+}
+/**
+ * Consumer-signup convenience: verify a token authorizes `create_account` at the
+ * identity-proofed tier. One line over `verifyHumanAction`.
+ */
+export async function verifyHumanSignup(req, opts = {}) {
+    return verifyHumanAction(req, {
+        ...opts,
+        action: "create_account",
+        requiredAuthLevel: "identity_proofed",
+    });
+}
+/** Map a `jose` (or network) error to a stable, fail-closed reason. */
+function mapError(err) {
+    // Network/fetch failures during JWKS retrieval aren't JOSEErrors → unreachable.
+    if (!(err instanceof errors.JOSEError))
+        return "jwks_unreachable";
+    switch (err.code) {
+        case "ERR_JWT_EXPIRED":
+            return "expired";
+        case "ERR_JWT_CLAIM_VALIDATION_FAILED": {
+            const claim = err.claim;
+            if (claim === "aud")
+                return "wrong_audience";
+            if (claim === "iss")
+                return "wrong_issuer";
+            if (claim === "nbf")
+                return "not_yet_valid";
+            return "malformed";
+        }
+        case "ERR_JWS_SIGNATURE_VERIFICATION_FAILED":
+        case "ERR_JOSE_ALG_NOT_ALLOWED":
+        case "ERR_JWKS_NO_MATCHING_KEY":
+        case "ERR_JWKS_MULTIPLE_MATCHING_KEYS":
+            return "bad_signature";
+        case "ERR_JWKS_TIMEOUT":
+        case "ERR_JWKS_INVALID":
+            return "jwks_unreachable";
+        case "ERR_JWT_INVALID":
+        case "ERR_JWS_INVALID":
+        case "ERR_JWE_INVALID":
+            return "malformed";
+        default:
+            return "bad_signature"; // unknown JOSE error → fail closed
+    }
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@tiertwo/sdk",
+  "version": "0.1.0",
+  "description": "One-call merchant SDK to verify Tier Two verified-human signup tokens — offline EdDSA/JWKS verification, fail-closed, with a jti replay-dedupe helper.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Tier Two",
+  "homepage": "https://github.com/Jordan-M/verified-human/tree/master/packages/sdk#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Jordan-M/verified-human.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/Jordan-M/verified-human/issues"
+  },
+  "keywords": [
+    "tiertwo",
+    "verified-human",
+    "jwt",
+    "jwks",
+    "eddsa",
+    "authentication",
+    "proof-of-personhood",
+    "mcp"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "jose": "^6.2.3",
+    "@tiertwo/shared": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.1",
+    "@types/node": "^20",
+    "express": "^5.1.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5",
+    "vitest": "^3.2.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "echo no-op",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "example:express": "tsx examples/express/server.ts"
+  }
+}