@oxy.so/contracts 1.0.0

package/dist/cjs/reputation.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * Oxy Trust — reputation API contracts.
+ *
+ * SINGLE SOURCE OF TRUTH for the reputation ledger's wire shapes: the closed
+ * value sets (`REPUTATION_CATEGORIES`, `TRUST_TIERS`, …), the response entities
+ * (`ReputationTransaction`, the two balance views, `ReputationDispute`,
+ * `ReputationRule`, the leaderboard entry) and the request bodies the write
+ * endpoints accept. The API validates its OUTPUT against these schemas and its
+ * INPUT with the same request schemas the SDK's input types are derived from;
+ * `@oxy.so/core`'s reputation mixin imports every type from here rather than
+ * declaring its own.
+ *
+ * Why this module exists: the balance endpoint was view-split server-side
+ * without the SDK type moving with it, and for hours the SDK affirmatively
+ * type-checked a read of `balance.reliability.reportAccuracyScore` against a
+ * response that no longer carried `reliability`. Nothing structural connected
+ * the API's hand-written serializers (which returned `Record<string, unknown>`)
+ * to the SDK's interfaces — only human attention. With the serializers
+ * annotated against these definitions, that divergence is a build failure.
+ *
+ * Design anchors:
+ *  - **Ids are strings, timestamps are ISO 8601 strings.** The server holds
+ *    `ObjectId`s and `Date`s; every serializer converts at the boundary, so a
+ *    `Date` leaking into a field this module types as `string` fails to compile.
+ *  - **The balance has two views, and the union is the contract.** See
+ *    {@link ReputationBalanceView} — the compile-time assertions below are what
+ *    stop the private view's fields becoming reachable on a stranger's balance.
+ *  - **The closed value sets live here, not beside the mongoose models.** The
+ *    API's model enums and the SDK's unions are the same `as const` tuple, so a
+ *    seventh category cannot be added on one side only.
+ *
+ * The response entities are declared as explicit `interface`s with their runtime
+ * schemas annotated `z.ZodType<Interface>`, following `./links` and
+ * `./userResponse`: a `z.infer<>` of a nested-object schema can degrade to `{}`
+ * under a consumer's `moduleResolution: "node"` (node10) resolution, while a
+ * literal interface emits the field types verbatim in the `.d.ts` and survives
+ * both `node` and `bundler`.
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo. ESM-safe (no
+ * `require()`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reverseReputationTransactionSchema = exports.upsertReputationRuleSchema = exports.resolveReputationDisputeSchema = exports.createReputationDisputeSchema = exports.awardReputationSchema = exports.reverseReputationTransactionResultSchema = exports.reputationInfluenceResultSchema = exports.reputationLeaderboardEntrySchema = exports.reputationLeaderboardUserSchema = exports.reputationRuleSchema = exports.reputationDisputeSchema = exports.reputationBalanceSchema = exports.reputationBalanceSummarySchema = exports.reputationReliabilitySchema = exports.reputationInfluenceSchema = exports.reputationBalanceBreakdownSchema = exports.reputationTransactionSchema = exports.reputationInfluenceContextSchema = exports.REPUTATION_INFLUENCE_CONTEXTS = exports.reputationDisputeStatusSchema = exports.REPUTATION_DISPUTE_STATUSES = exports.reputationTargetEntityTypeSchema = exports.REPUTATION_TARGET_ENTITY_TYPES = exports.trustTierSchema = exports.TRUST_TIERS = exports.reputationTransactionStatusSchema = exports.REPUTATION_TRANSACTION_STATUSES = exports.reputationCategorySchema = exports.REPUTATION_CATEGORIES = void 0;
+exports.isFullReputationBalance = isFullReputationBalance;
+const zod_1 = require("zod");
+const userResponse_1 = require("./userResponse");
+const moderationReputation_1 = require("./moderationReputation");
+/* -------------------------------------------------------------------------- */
+/*  Closed value sets                                                         */
+/* -------------------------------------------------------------------------- */
+/**
+ * Category bucket a reputation transaction falls into. Drives the per-category
+ * balance breakdown; every rule and transaction carries exactly one.
+ *
+ * - `content`    — posts, comments, media a user authored.
+ * - `social`     — follows, likes, social interactions.
+ * - `trust`      — identity / verification / trust-graph signals.
+ * - `moderation` — reports filed, moderation actions, review outcomes.
+ * - `physical`   — real-world signals (event check-ins, verified purchases).
+ * - `penalty`    — negative adjustments for abuse / policy violations.
+ * - `other`      — anything that does not fit the buckets above.
+ */
+exports.REPUTATION_CATEGORIES = [
+    'content',
+    'social',
+    'trust',
+    'moderation',
+    'physical',
+    'penalty',
+    'other',
+];
+exports.reputationCategorySchema = zod_1.z.enum(exports.REPUTATION_CATEGORIES);
+/**
+ * Transaction lifecycle status.
+ *
+ * - `active`   — counts toward the balance.
+ * - `disputed` — under dispute; still counts until the dispute resolves.
+ * - `reversed` — superseded by a compensating reversal transaction; excluded.
+ * - `voided`   — administratively excluded with no compensating entry.
+ */
+exports.REPUTATION_TRANSACTION_STATUSES = [
+    'active',
+    'disputed',
+    'reversed',
+    'voided',
+];
+exports.reputationTransactionStatusSchema = zod_1.z.enum(exports.REPUTATION_TRANSACTION_STATUSES);
+/**
+ * Trust tiers, lowest → highest trust, plus the punitive `restricted`.
+ *
+ * Publicly visible: this is the contribution ladder the reputation system
+ * exists to publish. Note it doubles as the sanction marker — a `restricted`
+ * account is publicly identifiable as such.
+ */
+exports.TRUST_TIERS = ['restricted', 'new', 'trusted', 'high_trust', 'verified'];
+exports.trustTierSchema = zod_1.z.enum(exports.TRUST_TIERS);
+/** Kind of entity a transaction may target. */
+exports.REPUTATION_TARGET_ENTITY_TYPES = [
+    'post',
+    'comment',
+    'report',
+    'purchase',
+    'event',
+    'check_in',
+    'manual_review',
+    'user',
+    'other',
+];
+exports.reputationTargetEntityTypeSchema = zod_1.z.enum(exports.REPUTATION_TARGET_ENTITY_TYPES);
+/** Dispute lifecycle status. */
+exports.REPUTATION_DISPUTE_STATUSES = [
+    'open',
+    'accepted',
+    'rejected',
+    'needs_review',
+];
+exports.reputationDisputeStatusSchema = zod_1.z.enum(exports.REPUTATION_DISPUTE_STATUSES);
+/** Influence context selecting which capped weight axis to read. */
+exports.REPUTATION_INFLUENCE_CONTEXTS = [
+    'default',
+    'report',
+    'moderation',
+    'ranking',
+];
+exports.reputationInfluenceContextSchema = zod_1.z.enum(exports.REPUTATION_INFLUENCE_CONTEXTS);
+exports.reputationTransactionSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    userId: zod_1.z.string(),
+    points: zod_1.z.number(),
+    actionType: zod_1.z.string(),
+    category: exports.reputationCategorySchema,
+    applicationId: zod_1.z.string().optional(),
+    credentialId: zod_1.z.string().optional(),
+    sourceActionId: zod_1.z.string().optional(),
+    sourceActionType: zod_1.z.string().optional(),
+    targetEntityId: zod_1.z.string().optional(),
+    targetEntityType: exports.reputationTargetEntityTypeSchema.optional(),
+    status: exports.reputationTransactionStatusSchema,
+    reversedTransactionId: zod_1.z.string().optional(),
+    reason: zod_1.z.string().optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).optional(),
+    createdByUserId: zod_1.z.string().optional(),
+    reviewedByUserId: zod_1.z.string().optional(),
+    reviewedAt: zod_1.z.string().optional(),
+    createdAt: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+});
+exports.reputationBalanceBreakdownSchema = zod_1.z.object({
+    content: zod_1.z.number(),
+    social: zod_1.z.number(),
+    trust: zod_1.z.number(),
+    moderation: zod_1.z.number(),
+    physical: zod_1.z.number(),
+    penalties: zod_1.z.number(),
+});
+exports.reputationInfluenceSchema = zod_1.z.object({
+    defaultWeight: zod_1.z.number(),
+    reportWeight: zod_1.z.number(),
+    moderationWeight: zod_1.z.number(),
+    rankingFeedbackWeight: zod_1.z.number(),
+});
+exports.reputationReliabilitySchema = zod_1.z.object({
+    accurateReports: zod_1.z.number(),
+    rejectedReports: zod_1.z.number(),
+    reportAccuracyScore: zod_1.z.number(),
+    abuseScore: zod_1.z.number(),
+});
+/** The fields both balance views share. Kept as a shape so the full view can spread it. */
+const balanceSummaryShape = {
+    userId: zod_1.z.string(),
+    total: zod_1.z.number(),
+    trustTier: exports.trustTierSchema,
+};
+exports.reputationBalanceSummarySchema = zod_1.z.object(balanceSummaryShape);
+exports.reputationBalanceSchema = zod_1.z.object({
+    ...balanceSummaryShape,
+    positive: zod_1.z.number(),
+    negative: zod_1.z.number(),
+    breakdown: exports.reputationBalanceBreakdownSchema,
+    influence: exports.reputationInfluenceSchema,
+    reliability: exports.reputationReliabilitySchema,
+    recalculatedAt: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+    personhood: moderationReputation_1.reputationPersonhoodSchema.optional(),
+    contribution: moderationReputation_1.reputationContributionSchema.optional(),
+    conduct: moderationReputation_1.reputationConductSchema.optional(),
+    reporting: moderationReputation_1.reputationReportingSchema.optional(),
+    reviewing: moderationReputation_1.reputationReviewingSchema.optional(),
+    contextualInfluence: moderationReputation_1.reputationContextualInfluenceSchema.optional(),
+});
+/**
+ * The fields the full {@link ReputationBalance} carries beyond the public
+ * {@link ReputationBalanceSummary} that the API sends ALL-OR-NOTHING. The
+ * runtime discriminant between the two views.
+ *
+ * The V2 blocks (`conduct`, `contribution`, …) are deliberately NOT listed:
+ * they are optional on the wire, so requiring them here would make a balance
+ * from a server that predates them fail to narrow, hiding the whole private
+ * view. Read a V2 block by checking that block.
+ */
+const FULL_BALANCE_FIELDS = [
+    'positive',
+    'negative',
+    'breakdown',
+    'influence',
+    'reliability',
+    'recalculatedAt',
+    'updatedAt',
+];
+/**
+ * Whether a balance came back as the SUBJECT view, and so carries the
+ * breakdown / influence / reliability blocks.
+ *
+ * Checks every extra field rather than one representative: the point of the
+ * guard is that the caller then dereferences those blocks, so a partial payload
+ * must not narrow.
+ *
+ * @param balance - A balance from `getReputationBalance`.
+ */
+function isFullReputationBalance(balance) {
+    return FULL_BALANCE_FIELDS.every((field) => field in balance);
+}
+exports.reputationDisputeSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    transactionId: zod_1.z.string(),
+    userId: zod_1.z.string(),
+    reason: zod_1.z.string(),
+    status: exports.reputationDisputeStatusSchema,
+    evidence: zod_1.z.array(zod_1.z.string()).optional(),
+    resolvedAt: zod_1.z.string().optional(),
+    resolvedByUserId: zod_1.z.string().optional(),
+    createdAt: zod_1.z.string(),
+    updatedAt: zod_1.z.string(),
+});
+exports.reputationRuleSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    actionType: zod_1.z.string(),
+    points: zod_1.z.number(),
+    category: exports.reputationCategorySchema,
+    description: zod_1.z.string(),
+    cooldownInMinutes: zod_1.z.number(),
+    isEnabled: zod_1.z.boolean(),
+});
+exports.reputationLeaderboardUserSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    username: zod_1.z.string(),
+    name: userResponse_1.userNameSchema,
+    avatar: zod_1.z.string().optional(),
+    publicKey: zod_1.z.string().optional(),
+});
+exports.reputationLeaderboardEntrySchema = zod_1.z.object({
+    user: exports.reputationLeaderboardUserSchema,
+    total: zod_1.z.number(),
+    trustTier: exports.trustTierSchema,
+    rank: zod_1.z.number(),
+});
+exports.reputationInfluenceResultSchema = zod_1.z.object({
+    context: exports.reputationInfluenceContextSchema,
+    weight: zod_1.z.number(),
+    influence: exports.reputationInfluenceSchema,
+});
+exports.reverseReputationTransactionResultSchema = zod_1.z.object({
+    original: exports.reputationTransactionSchema,
+    reversal: exports.reputationTransactionSchema,
+});
+exports.awardReputationSchema = zod_1.z.object({
+    userId: zod_1.z.string().trim().min(1),
+    actionType: zod_1.z.string().trim().min(1),
+    applicationId: zod_1.z.string().trim().min(1).optional(),
+    credentialId: zod_1.z.string().trim().min(1).optional(),
+    sourceActionId: zod_1.z.string().trim().min(1).optional(),
+    sourceActionType: zod_1.z.string().trim().min(1).optional(),
+    targetEntityId: zod_1.z.string().trim().min(1).optional(),
+    targetEntityType: exports.reputationTargetEntityTypeSchema.optional(),
+    reason: zod_1.z.string().trim().max(500).optional(),
+    metadata: zod_1.z.record(zod_1.z.unknown()).optional(),
+});
+exports.createReputationDisputeSchema = zod_1.z.object({
+    transactionId: zod_1.z.string().trim().min(1),
+    reason: zod_1.z.string().trim().min(1).max(1000),
+    evidence: zod_1.z.array(zod_1.z.string().trim().min(1)).max(20).optional(),
+});
+exports.resolveReputationDisputeSchema = zod_1.z.object({
+    status: zod_1.z.enum(['accepted', 'rejected']),
+});
+exports.upsertReputationRuleSchema = zod_1.z.object({
+    actionType: zod_1.z.string().trim().min(1),
+    points: zod_1.z.number(),
+    category: exports.reputationCategorySchema,
+    description: zod_1.z.string().trim().min(1).max(500),
+    cooldownInMinutes: zod_1.z.number().int().min(0).default(0),
+    isEnabled: zod_1.z.boolean().default(true),
+});
+exports.reverseReputationTransactionSchema = zod_1.z.object({
+    reason: zod_1.z.string().trim().max(500).optional(),
+});

package/dist/cjs/sessionStatus.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Canonical contract for `GET /auth/session/status/:sessionToken`.
+ *
+ * SINGLE SOURCE OF TRUTH for the wire shape of the cross-app device-flow
+ * session-status payload and the sanitized public application identity it
+ * embeds. The API validates its OUTPUT against these schemas; the auth app
+ * (consent UI) validates its INPUT against the same schemas. Because there is
+ * exactly one definition, the producer and the consumer cannot drift.
+ *
+ * The class of bug that motivated moving this into `@oxy.so/contracts`: the auth
+ * app's LOCAL `sessionStatusSchema` typed `sessionId` as a non-nullable
+ * `z.string().optional()`. The producer emits `sessionId: authorizedSessionId ||
+ * null`, so a PENDING session (not yet authorized) carries `sessionId: null` —
+ * `.optional()` permits `undefined`/missing but REJECTS `null`, so `safeParse`
+ * failed, the whole response collapsed to `null`, and the consent screen showed
+ * "Unable to identify the requesting application". Pinning the nullability in one
+ * shared place makes that drift impossible.
+ *
+ * Faithful to the producers:
+ *  - `packages/api/src/utils/serializeApplication.ts` `serializePublicApplication`
+ *    — the ONLY shape returned to an unauthenticated consent UI. Optional fields
+ *    (`description`, `icon`, `websiteUrl`, `privacyPolicyUrl`, `termsUrl`,
+ *    `developerName`) are OMITTED when absent (never serialized as `null`), so
+ *    they are `.optional()` — NOT `.nullable()`. `type` is the `Application.type`
+ *    enum.
+ *  - `packages/api/src/routes/auth.ts` `GET /session/status/:sessionToken` — the
+ *    inner object of the API's `{ data: ... }` success envelope. The handler
+ *    ALWAYS emits `status`, `authorized` (`status === 'authorized'`),
+ *    `sessionToken`, `expiresAt` (ISO string), and `application` (resolved object
+ *    OR `null`). It ALWAYS emits `sessionId` / `publicKey` / `userId`, each as a
+ *    string value OR `null` (`authorizedSessionId || null`, `authorizedBy ||
+ *    null`, `authorizedUserId?.toString() || null`).
+ *
+ * Platform-agnostic — zod only, no react/react-native/expo. ESM-safe (no
+ * `require()`).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionStatusSchema = exports.publicApplicationSchema = exports.applicationTypeSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Application `type` enum. Mirrors `APPLICATION_TYPES` in
+ * `packages/api/src/models/Application.ts` (`first_party` | `third_party` |
+ * `internal` | `system`).
+ */
+exports.applicationTypeSchema = zod_1.z.enum([
+    'first_party',
+    'third_party',
+    'internal',
+    'system',
+]);
+/**
+ * The display-safe public identity of a requesting application, exactly as
+ * `serializePublicApplication` emits it. Returned by the API inside
+ * `GET /auth/session/status/:sessionToken` (device flow) and
+ * `GET /auth/oauth/client/:clientId` (OAuth code flow).
+ *
+ * Optional fields are `.optional()` (NOT `.nullable()`): the serializer OMITS
+ * `description` / `icon` / `websiteUrl` / `privacyPolicyUrl` / `termsUrl` /
+ * `developerName` when the underlying value is absent — it never writes `null`
+ * for them. `developerName` is only attached for non-official apps when a name
+ * could be resolved.
+ */
+exports.publicApplicationSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    icon: zod_1.z.string().optional(),
+    websiteUrl: zod_1.z.string().optional(),
+    privacyPolicyUrl: zod_1.z.string().optional(),
+    termsUrl: zod_1.z.string().optional(),
+    type: exports.applicationTypeSchema,
+    isOfficial: zod_1.z.boolean(),
+    isInternal: zod_1.z.boolean(),
+    scopes: zod_1.z.array(zod_1.z.string()),
+    developerName: zod_1.z.string().optional(),
+});
+/**
+ * The inner object of `GET /auth/session/status/:sessionToken` (inside the API's
+ * `{ data: ... }` envelope).
+ *
+ * `application` is the resolved {@link publicApplicationSchema} identity of the
+ * requesting application, or `null` when the bound app was hard-deleted / is no
+ * longer `active` (defensive — normally always present).
+ *
+ * `sessionId` / `publicKey` / `userId` are `.nullable().optional()`: the producer
+ * ALWAYS emits the key, with a string for an AUTHORIZED session or `null` for a
+ * PENDING one. `.nullable()` accepts the PENDING `null`; `.optional()` is belt-
+ * and-braces so a consumer is never broken by a future projection that drops the
+ * key. (`.optional()` alone would REJECT the PENDING `null` — that was the bug.)
+ *
+ * `authorized` / `sessionToken` / `expiresAt` are emitted unconditionally by the
+ * current producer and are never `null`, but stay `.optional()` so the contract
+ * tolerates leaner shapes from other producers of this same payload without a
+ * coordinated bump.
+ *
+ * `pushSentAt` / `openedAt` are DELIVERY PROGRESS, not authorization state: they
+ * let a waiting surface render "Check Commons on your phone" → "Opened in
+ * Commons" without inventing competing statuses. `status` remains the only
+ * authority on whether the request is pending, authorized, cancelled or expired.
+ * Both are `.nullable().optional()` for the same reason as `sessionId` — the
+ * producer always emits the key with `null` until that step happens, and an
+ * older API that omits them entirely must degrade, not fail the parse.
+ */
+exports.sessionStatusSchema = zod_1.z.object({
+    status: zod_1.z.string(),
+    authorized: zod_1.z.boolean().optional(),
+    sessionToken: zod_1.z.string().optional(),
+    application: exports.publicApplicationSchema.nullable().optional(),
+    expiresAt: zod_1.z.string().optional(),
+    sessionId: zod_1.z.string().nullable().optional(),
+    publicKey: zod_1.z.string().nullable().optional(),
+    userId: zod_1.z.string().nullable().optional(),
+    /**
+     * What approving this request does. Legacy rows read as `device_sign_in`.
+     * OAuth-bound sessions finalize into an authorization code (no `sessionId`).
+     */
+    purpose: zod_1.z.enum(['device_sign_in', 'oauth_authorization']).optional(),
+    pushSentAt: zod_1.z.string().nullable().optional(),
+    openedAt: zod_1.z.string().nullable().optional(),
+});

package/dist/cjs/transparency.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transparencyCheckpointListSchema = exports.transparencyInclusionProofSchema = exports.transparencyCheckpointSchema = exports.transparencyAnchorSchema = exports.transparencyCheckpointSignatureSchema = void 0;
+const zod_1 = require("zod");
+/**
+ * Transparency log — the public wire contract of the checkpoint surface.
+ *
+ * A checkpoint is the operator's signed commitment to EVERY subject's chain head
+ * at a point in time: "at `periodEnd` I committed to `root` over `treeSize`
+ * subjects, and the previous checkpoint hashed to `prevCheckpointHash`". Anyone
+ * can then ask for an inclusion proof of their own head and verify it against
+ * that root without trusting the server — which is what closes the one gap a
+ * per-subject hash chain cannot close on its own (the server serving two
+ * different histories, or quietly dropping a record).
+ *
+ * The Merkle math, the leaf/checkpoint signing bytes, and the proof verifier all
+ * live in `@oxy.so/protocol` (`src/transparency/`); this module only fixes the
+ * SHAPES that cross the wire, so a client and the API cannot drift on them.
+ *
+ * Digest fields are pinned to 64-char LOWERCASE hex on purpose: the digests are
+ * compared as strings against locally recomputed hashes, so accepting an
+ * upper-case or truncated variant would turn a real mismatch into a confusing
+ * verification failure at a distance.
+ */
+/** A SHA-256 digest in the exact form the protocol emits: 64 lowercase hex chars. */
+const hexDigestSchema = zod_1.z.string().regex(/^[0-9a-f]{64}$/, 'Expected a 64-char lowercase hex digest');
+/**
+ * One signer's endorsement of a checkpoint's signed fields.
+ *
+ * The operator and every independent witness produce this same shape over the
+ * SAME bytes, so the array on a checkpoint can grow without coordination.
+ */
+exports.transparencyCheckpointSignatureSchema = zod_1.z.object({
+    /** Uncompressed hex public key of the signer. */
+    publicKey: zod_1.z.string().min(1),
+    alg: zod_1.z.literal('ES256K-DER-SHA256'),
+    /** DER-encoded hex secp256k1 signature over the checkpoint signing input. */
+    signature: zod_1.z.string().min(1),
+});
+/** Where a checkpoint root was published on a public chain. */
+exports.transparencyAnchorSchema = zod_1.z.object({
+    /** Chain/network identifier, e.g. `faircoin-main`. */
+    network: zod_1.z.string().min(1),
+    txid: zod_1.z.string().min(1),
+    confirmations: zod_1.z.number().int().nonnegative(),
+    /** When the anchoring transaction was broadcast (ms epoch). */
+    anchoredAt: zod_1.z.number().int().positive(),
+});
+/**
+ * A published checkpoint.
+ *
+ * `signatures` is non-empty by contract: an unsigned root commits nobody and
+ * must never be served as a checkpoint. `anchors` may be empty — a checkpoint is
+ * published immediately and anchored asynchronously, so "not yet anchored" is a
+ * normal, temporary state rather than an error.
+ */
+exports.transparencyCheckpointSchema = zod_1.z.object({
+    index: zod_1.z.number().int().nonnegative(),
+    /** End of the committed period (ms epoch). */
+    periodEnd: zod_1.z.number().int().positive(),
+    /** Number of subjects (leaves) committed. */
+    treeSize: zod_1.z.number().int().nonnegative(),
+    root: hexDigestSchema,
+    /** Hash of the previous checkpoint; `null` only at genesis. */
+    prevCheckpointHash: hexDigestSchema.nullable(),
+    signatures: zod_1.z.array(exports.transparencyCheckpointSignatureSchema).min(1),
+    anchors: zod_1.z.array(exports.transparencyAnchorSchema),
+});
+/**
+ * An inclusion proof for one subject against one checkpoint.
+ *
+ * Carries the leaf PREIMAGE (`subjectDid`, `seq`, `headRecordId`) as well as the
+ * `leaf` digest so the verifier re-derives the leaf itself rather than trusting
+ * the server's hash, then walks `proof` up to the checkpoint's `root`.
+ */
+exports.transparencyInclusionProofSchema = zod_1.z.object({
+    checkpoint: exports.transparencyCheckpointSchema,
+    subjectDid: zod_1.z.string().min(1),
+    seq: zod_1.z.number().int().nonnegative(),
+    headRecordId: hexDigestSchema,
+    leaf: hexDigestSchema,
+    leafIndex: zod_1.z.number().int().nonnegative(),
+    /** Audit path, leaf-adjacent sibling first; empty for a single-leaf tree. */
+    proof: zod_1.z.array(hexDigestSchema),
+});
+/** A page of the checkpoint chain, oldest first, for walking `prevCheckpointHash`. */
+exports.transparencyCheckpointListSchema = zod_1.z.object({
+    checkpoints: zod_1.z.array(exports.transparencyCheckpointSchema),
+});