@hypercerts-org/lexicon 0.10.0-beta.9 → 0.11.0

package/dist/lexicons.mjs

@@ -28,6 +28,214 @@ function maybe$typed(v, id, hash) {
  * GENERATED CODE - DO NOT MODIFY
  */
 const schemaDict = {
+    AppBskyRichtextFacet: {
+        lexicon: 1,
+        id: 'app.bsky.richtext.facet',
+        defs: {
+            main: {
+                type: 'object',
+                description: 'Annotation of a sub-string within rich text.',
+                required: ['index', 'features'],
+                properties: {
+                    index: {
+                        type: 'ref',
+                        ref: 'lex:app.bsky.richtext.facet#byteSlice',
+                    },
+                    features: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:app.bsky.richtext.facet#mention',
+                                'lex:app.bsky.richtext.facet#link',
+                                'lex:app.bsky.richtext.facet#tag',
+                            ],
+                        },
+                    },
+                },
+            },
+            mention: {
+                type: 'object',
+                description: "Facet feature for mention of another account. The text is usually a handle, including a '@' prefix, but the facet reference is a DID.",
+                required: ['did'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                    },
+                },
+            },
+            link: {
+                type: 'object',
+                description: 'Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.',
+                required: ['uri'],
+                properties: {
+                    uri: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+            tag: {
+                type: 'object',
+                description: "Facet feature for a hashtag. The text usually includes a '#' prefix, but the facet reference should not (except in the case of 'double hash tags').",
+                required: ['tag'],
+                properties: {
+                    tag: {
+                        type: 'string',
+                        maxLength: 640,
+                        maxGraphemes: 64,
+                    },
+                },
+            },
+            byteSlice: {
+                type: 'object',
+                description: 'Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.',
+                required: ['byteStart', 'byteEnd'],
+                properties: {
+                    byteStart: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                    byteEnd: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                },
+            },
+        },
+    },
+    AppCertifiedActorOrganization: {
+        lexicon: 1,
+        id: 'app.certified.actor.organization',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'Extended metadata for an organization actor. Complements the base actor profile with organization-specific fields like legal structure and reference links.',
+                key: 'literal:self',
+                record: {
+                    type: 'object',
+                    required: ['createdAt'],
+                    properties: {
+                        organizationType: {
+                            type: 'array',
+                            description: "Legal or operational structures of the organization (e.g. 'nonprofit', 'ngo', 'government', 'social-enterprise', 'cooperative').",
+                            items: {
+                                type: 'string',
+                                maxLength: 128,
+                                maxGraphemes: 100,
+                            },
+                            maxLength: 10,
+                        },
+                        urls: {
+                            type: 'array',
+                            description: 'Additional reference URLs (social media profiles, contact pages, donation links, etc.) with a display label for each URL.',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.certified.actor.organization#urlItem',
+                            },
+                        },
+                        location: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'A strong reference to the location where the organization is based. The record referenced must conform with the lexicon app.certified.location.',
+                        },
+                        foundedDate: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: "When the organization was established. Stored as datetime per ATProto conventions (no date-only format exists). Clients should use midnight UTC (e.g., '2005-01-01T00:00:00.000Z'); consumers should treat only the date portion as canonical.",
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
+                        },
+                    },
+                },
+            },
+            urlItem: {
+                type: 'object',
+                description: 'A labeled URL reference.',
+                required: ['url'],
+                properties: {
+                    url: {
+                        type: 'string',
+                        format: 'uri',
+                        description: 'The URL.',
+                        maxLength: 10000,
+                        maxGraphemes: 2048,
+                    },
+                    label: {
+                        type: 'string',
+                        description: "Optional human-readable label for this URL (e.g. 'Support page', 'Donation page').",
+                        maxLength: 640,
+                        maxGraphemes: 64,
+                    },
+                },
+            },
+        },
+    },
+    AppCertifiedActorProfile: {
+        lexicon: 1,
+        id: 'app.certified.actor.profile',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A declaration of a Certified account profile.',
+                key: 'literal:self',
+                record: {
+                    type: 'object',
+                    required: ['createdAt'],
+                    properties: {
+                        displayName: {
+                            type: 'string',
+                            description: 'Display name for the account',
+                            maxGraphemes: 64,
+                            maxLength: 640,
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Free-form profile description text.',
+                            maxGraphemes: 256,
+                            maxLength: 2560,
+                        },
+                        pronouns: {
+                            type: 'string',
+                            description: 'Free-form pronouns text.',
+                            maxGraphemes: 20,
+                            maxLength: 200,
+                        },
+                        website: {
+                            type: 'string',
+                            format: 'uri',
+                            description: 'Account website URL',
+                        },
+                        avatar: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+                        },
+                        banner: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#largeImage',
+                            ],
+                            description: 'Larger horizontal image to display behind profile view.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+        },
+    },
     AppCertifiedBadgeAward: {
         lexicon: 1,
         id: 'app.certified.badge.award',
@@ -42,8 +250,8 @@ const schemaDict = {
                     properties: {
                         badge: {
                             type: 'ref',
-                            ref: 'lex:app.certified.badge.definition',
-                            description: 'Reference to the badge definition for this award.',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Strong reference to the badge definition at the time of award. The record referenced must conform with the lexicon app.certified.badge.definition.',
                         },
                         subject: {
                             type: 'union',
@@ -56,6 +264,13 @@ const schemaDict = {
                         note: {
                             type: 'string',
                             description: 'Optional statement explaining the reason for this badge award.',
+                            maxLength: 500,
+                        },
+                        url: {
+                            type: 'string',
+                            format: 'uri',
+                            description: 'Optional URL the badge award links to.',
+                            maxLength: 2048,
                         },
                         createdAt: {
                             type: 'string',
@@ -77,15 +292,25 @@ const schemaDict = {
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['title', 'badgeType', 'icon', 'createdAt'],
+                    required: ['title', 'badgeType', 'createdAt'],
                     properties: {
                         badgeType: {
                             type: 'string',
-                            description: 'Category of the badge (e.g. endorsement, participation, affiliation).',
+                            description: 'Category of the badge. Values beyond the known set are permitted.',
+                            knownValues: [
+                                'endorsement',
+                                'verification',
+                                'participation',
+                                'certification',
+                                'affiliation',
+                                'recognition',
+                            ],
+                            maxLength: 100,
                         },
                         title: {
                             type: 'string',
                             description: 'Human-readable title of the badge.',
+                            maxLength: 256,
                         },
                         icon: {
                             type: 'blob',
@@ -101,10 +326,13 @@ const schemaDict = {
                         description: {
                             type: 'string',
                             description: 'Optional short statement describing what the badge represents.',
+                            maxLength: 5000,
+                            maxGraphemes: 500,
                         },
                         allowedIssuers: {
                             type: 'array',
                             description: 'Optional allowlist of DIDs allowed to issue this badge. If omitted, anyone may issue it.',
+                            maxLength: 100,
                             items: {
                                 type: 'ref',
                                 ref: 'lex:app.certified.defs#did',
@@ -134,17 +362,18 @@ const schemaDict = {
                     properties: {
                         badgeAward: {
                             type: 'ref',
-                            ref: 'lex:app.certified.badge.award',
-                            description: 'Reference to the badge award.',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Strong reference to the badge award being responded to. The record referenced must conform with the lexicon app.certified.badge.award.',
                         },
                         response: {
                             type: 'string',
-                            enum: ['accepted', 'rejected'],
+                            knownValues: ['accepted', 'rejected'],
                             description: 'The recipient’s response for the badge (accepted or rejected).',
                         },
                         weight: {
                             type: 'string',
                             description: 'Optional relative weight for accepted badges, assigned by the recipient.',
+                            maxLength: 50,
                         },
                         createdAt: {
                             type: 'string',
@@ -162,9 +391,105 @@ const schemaDict = {
         description: 'Common type definitions used across certified protocols.',
         defs: {
             did: {
-                type: 'string',
-                format: 'did',
+                type: 'object',
                 description: 'A Decentralized Identifier (DID) string.',
+                required: ['did'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                        description: 'The DID string value.',
+                        maxLength: 256,
+                    },
+                },
+            },
+        },
+    },
+    AppCertifiedLinkEvm: {
+        lexicon: 1,
+        id: 'app.certified.link.evm',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A verifiable link between an ATProto DID and an EVM wallet address, proven via a cryptographic signature. Currently supports EOA wallets via EIP-712 typed data signatures; the proof field is an open union to allow future signature methods.',
+                key: 'any',
+                record: {
+                    type: 'object',
+                    required: ['address', 'proof', 'createdAt'],
+                    properties: {
+                        address: {
+                            type: 'string',
+                            description: 'EVM wallet address (0x-prefixed, with EIP-55 checksum recommended).',
+                            minLength: 42,
+                            maxLength: 42,
+                        },
+                        proof: {
+                            type: 'union',
+                            refs: ['lex:app.certified.link.evm#eip712Proof'],
+                            description: 'Cryptographic proof of wallet ownership. The union is open to allow future proof methods (e.g. ERC-1271, ERC-6492). Each variant bundles its signature with the corresponding message format.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
+                        },
+                    },
+                },
+            },
+            eip712Proof: {
+                type: 'object',
+                description: 'EOA wallet ownership proof via EIP-712 typed data signature. Contains both the structured message that was signed and the resulting signature.',
+                required: ['signature', 'message'],
+                properties: {
+                    signature: {
+                        type: 'string',
+                        description: 'ECDSA signature over the EIP-712 hash (hex-encoded with 0x prefix, 64 or 65 bytes).',
+                        minLength: 130,
+                        maxLength: 132,
+                    },
+                    message: {
+                        type: 'ref',
+                        ref: 'lex:app.certified.link.evm#eip712Message',
+                        description: 'The EIP-712 structured message fields that were signed.',
+                    },
+                },
+            },
+            eip712Message: {
+                type: 'object',
+                description: 'The EIP-712 typed data message that was signed by the wallet. Contains the fields binding an ATProto DID to an EVM address on a specific chain.',
+                required: ['did', 'evmAddress', 'chainId', 'timestamp', 'nonce'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                        description: 'The ATProto DID being linked to the EVM address.',
+                        maxLength: 256,
+                    },
+                    evmAddress: {
+                        type: 'string',
+                        description: 'The EVM wallet address (must match the top-level address field).',
+                        minLength: 42,
+                        maxLength: 42,
+                    },
+                    chainId: {
+                        type: 'string',
+                        description: 'EVM chain ID as string (bigint serialized). Identifies which chain was used for signing; for EOA wallets the identity link applies across all EVM-compatible chains.',
+                        minLength: 1,
+                        maxLength: 78,
+                    },
+                    timestamp: {
+                        type: 'string',
+                        description: 'Unix timestamp when the attestation was created (bigint serialized).',
+                        minLength: 1,
+                        maxLength: 78,
+                    },
+                    nonce: {
+                        type: 'string',
+                        description: 'Replay-protection nonce (bigint serialized).',
+                        minLength: 1,
+                        maxLength: 78,
+                    },
+                },
             },
         },
     },
@@ -199,8 +524,17 @@ const schemaDict = {
                         },
                         locationType: {
                             type: 'string',
-                            description: 'An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point)',
-                            knownValues: ['coordinate-decimal', 'geojson-point'],
+                            description: 'An identifier for the format of the location data (e.g., coordinate-decimal, geojson-point). See the Location Protocol spec for the full registry: https://spec.decentralizedgeo.org/specification/location-types/#location-type-registry',
+                            knownValues: [
+                                'coordinate-decimal',
+                                'geojson-point',
+                                'geojson',
+                                'h3',
+                                'geohash',
+                                'wkt',
+                                'address',
+                                'scaledCoordinates',
+                            ],
                             maxLength: 20,
                         },
                         location: {
@@ -208,18 +542,19 @@ const schemaDict = {
                             refs: [
                                 'lex:org.hypercerts.defs#uri',
                                 'lex:org.hypercerts.defs#smallBlob',
+                                'lex:app.certified.location#string',
                             ],
-                            description: 'The location of where the work was performed as a URI or blob.',
+                            description: 'The location of where the work was performed as a URI, blob, or inline string.',
                         },
                         name: {
                             type: 'string',
-                            description: 'Optional name for this location',
+                            description: "Human-readable name for this location (e.g. 'Golden Gate Park', 'San Francisco Bay Area')",
                             maxLength: 1000,
                             maxGraphemes: 100,
                         },
                         description: {
                             type: 'string',
-                            description: 'Optional description for this location',
+                            description: 'Additional context about this location, such as its significance to the work or specific boundaries',
                             maxLength: 2000,
                             maxGraphemes: 500,
                         },
@@ -231,6 +566,19 @@ const schemaDict = {
                     },
                 },
             },
+            string: {
+                type: 'object',
+                required: ['string'],
+                description: 'A location represented as a string, e.g. coordinates or a small GeoJSON string.',
+                properties: {
+                    string: {
+                        type: 'string',
+                        description: 'The location string value',
+                        maxLength: 10000,
+                        maxGraphemes: 1000,
+                    },
+                },
+            },
         },
     },
     ComAtprotoRepoStrongRef: {
@@ -254,203 +602,322 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimActivity: {
+    OrgHyperboardsBoard: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.activity',
+        id: 'org.hyperboards.board',
         defs: {
             main: {
                 type: 'record',
-                description: 'A hypercert record tracking impact work.',
-                key: 'any',
+                description: "Configuration record for a hyperboard, wrapping an underlying activity or collection with visual presentation settings. Stored in the creator's PDS.",
+                key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['title', 'shortDescription', 'createdAt'],
+                    required: ['subject', 'createdAt'],
                     properties: {
-                        title: {
-                            type: 'string',
-                            description: 'Title of the hypercert.',
-                            maxLength: 256,
-                        },
-                        shortDescription: {
-                            type: 'string',
-                            description: 'Short summary of this activity claim, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
-                            maxLength: 3000,
-                            maxGraphemes: 300,
-                        },
-                        shortDescriptionFacets: {
-                            type: 'array',
-                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:app.bsky.richtext.facet',
-                            },
+                        subject: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Reference to the org.hypercerts.claim.activity or org.hypercerts.claim.collection this board visualizes.',
                         },
-                        description: {
-                            type: 'string',
-                            description: 'Optional longer description of this activity claim, including context or interpretation. Rich text annotations may be provided via `descriptionFacets`.',
-                            maxLength: 30000,
-                            maxGraphemes: 3000,
+                        config: {
+                            type: 'ref',
+                            ref: 'lex:org.hyperboards.board#boardConfig',
+                            description: 'Board-level visual configuration (background, colors, aspect ratio).',
                         },
-                        descriptionFacets: {
+                        contributorConfigs: {
                             type: 'array',
-                            description: 'Rich text annotations for `description` (mentions, URLs, hashtags, etc).',
+                            description: 'Per-contributor configuration entries for this board.',
+                            maxLength: 1000,
                             items: {
                                 type: 'ref',
-                                ref: 'lex:app.bsky.richtext.facet',
+                                ref: 'lex:org.hyperboards.board#contributorConfig',
                             },
                         },
-                        image: {
-                            type: 'union',
-                            refs: [
-                                'lex:org.hypercerts.defs#uri',
-                                'lex:org.hypercerts.defs#smallImage',
-                            ],
-                            description: 'The hypercert visual representation as a URI or image blob.',
-                        },
-                        workScope: {
-                            type: 'union',
-                            refs: [
-                                'lex:org.hypercerts.defs#workScopeAll',
-                                'lex:org.hypercerts.defs#workScopeAny',
-                                'lex:org.hypercerts.defs#workScopeNot',
-                                'lex:org.hypercerts.defs#workScopeAtom',
-                            ],
-                            description: 'Work scope logic expression using boolean operators (all/any/not) and atomic scope references.',
-                        },
-                        startDate: {
+                        createdAt: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'When the work began',
-                        },
-                        endDate: {
-                            type: 'string',
-                            format: 'datetime',
-                            description: 'When the work ended',
-                        },
-                        contributors: {
-                            type: 'array',
-                            description: 'An array of contributor objects, each containing contributor information, weight, and contribution details.',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:org.hypercerts.claim.activity#contributor',
-                            },
-                        },
-                        rights: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights.',
-                        },
-                        locations: {
-                            type: 'array',
-                            description: 'An array of strong references to the location where activity was performed. The record referenced must conform with the lexicon app.certified.location.',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:com.atproto.repo.strongRef',
-                            },
-                        },
-                        createdAt: {
-                            type: 'string',
-                            format: 'datetime',
-                            description: 'Client-declared timestamp when this record was originally created',
+                            description: 'Client-declared timestamp when this record was originally created.',
                         },
                     },
                 },
             },
-            contributor: {
+            boardConfig: {
                 type: 'object',
-                required: ['contributorIdentity'],
+                description: "Visual configuration for a hyperboard's background, colors, and layout.",
                 properties: {
-                    contributorIdentity: {
+                    backgroundType: {
+                        type: 'string',
+                        description: 'Type of background content.',
+                        knownValues: ['image', 'iframe'],
+                        maxLength: 10,
+                    },
+                    backgroundImage: {
                         type: 'union',
                         refs: [
-                            'lex:org.hypercerts.claim.activity#contributorIdentity',
-                            'lex:com.atproto.repo.strongRef',
+                            'lex:org.hypercerts.defs#uri',
+                            'lex:org.hypercerts.defs#smallImage',
                         ],
-                        description: 'Contributor identity as a string (DID or identifier) via org.hypercerts.claim.activity#contributorIdentity, or a strong reference to a contributor information record.',
+                        description: 'Background image as a URI or image blob.',
                     },
-                    contributionWeight: {
+                    backgroundIframeUrl: {
                         type: 'string',
-                        description: 'The relative weight/importance of this contribution (stored as a string to avoid float precision issues). Must be a positive numeric value. Weights do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
+                        format: 'uri',
+                        description: 'URI of the background iframe.',
+                        maxLength: 2048,
                     },
-                    contributionDetails: {
+                    backgroundGrayscale: {
+                        type: 'boolean',
+                        description: 'Whether the background is rendered in grayscale. Default: true.',
+                    },
+                    backgroundOpacity: {
+                        type: 'integer',
+                        description: 'Background opacity as a percentage (0–100).',
+                        minimum: 0,
+                        maximum: 100,
+                    },
+                    backgroundColor: {
+                        type: 'string',
+                        description: "Background color as a hex string (e.g. '#ffffff').",
+                        maxLength: 20,
+                    },
+                    borderColor: {
+                        type: 'string',
+                        description: "Border color as a hex string (e.g. '#000000').",
+                        maxLength: 20,
+                    },
+                    grayscaleImages: {
+                        type: 'boolean',
+                        description: 'Whether contributor images are rendered in grayscale. Default: false.',
+                    },
+                    imageShape: {
+                        type: 'string',
+                        description: 'Shape used to crop contributor images on this board.',
+                        knownValues: ['circular', 'square'],
+                        maxLength: 20,
+                    },
+                    aspectRatio: {
+                        type: 'string',
+                        description: 'Display aspect ratio of the board.',
+                        knownValues: ['16:9', '4:3', '1:1'],
+                        maxLength: 10,
+                    },
+                },
+            },
+            contributorConfig: {
+                type: 'object',
+                description: 'Configuration for a specific contributor within a board. Values serve as fallbacks when the contributor has not defined them on their profile. It can also be used to override contributor settings on this board without changing their global profile.',
+                required: ['contributor'],
+                properties: {
+                    contributor: {
                         type: 'union',
                         refs: [
-                            'lex:org.hypercerts.claim.activity#contributorRole',
                             'lex:com.atproto.repo.strongRef',
+                            'lex:org.hypercerts.claim.activity#contributorIdentity',
+                        ],
+                        description: 'Identifies the contributor being styled. A strong reference to an org.hypercerts.claim.contributorInformation record, or a contributorIdentity (DID or identifier string) for contributors without a dedicated record.',
+                    },
+                    override: {
+                        type: 'boolean',
+                        description: "When true, these values take precedence over the contributor's own profile and display settings. When false or omitted, they are only used as fallbacks if the contributor has not set their own settings.",
+                    },
+                    displayName: {
+                        type: 'string',
+                        description: 'Display name for this contributor on this board.',
+                        maxLength: 640,
+                        maxGraphemes: 64,
+                    },
+                    image: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.defs#uri',
+                            'lex:org.hypercerts.defs#smallImage',
+                        ],
+                        description: 'Avatar or face image for this contributor on this board, as a URI or image blob.',
+                    },
+                    video: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.defs#uri',
+                            'lex:org.hypercerts.defs#smallVideo',
                         ],
-                        description: 'Contribution details as a string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record.',
+                        description: 'Video for this contributor, as a URI (embed/direct link) or uploaded video blob.',
+                    },
+                    hoverImage: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.defs#uri',
+                            'lex:org.hypercerts.defs#smallImage',
+                        ],
+                        description: 'Image overlay shown when hovering over this contributor, as a URI or image blob.',
+                    },
+                    hoverIframeUrl: {
+                        type: 'string',
+                        format: 'uri',
+                        description: 'Iframe overlay shown when hovering over this contributor.',
+                        maxLength: 2048,
+                    },
+                    url: {
+                        type: 'string',
+                        format: 'uri',
+                        description: 'Click-through link URL for this contributor.',
+                        maxLength: 2048,
                     },
                 },
             },
-            contributorIdentity: {
-                type: 'string',
-                description: 'Contributor information as a string (DID or identifier).',
-            },
-            contributorRole: {
-                type: 'string',
-                description: 'Contribution details as a string.',
-                maxLength: 10000,
-                maxGraphemes: 1000,
-            },
         },
     },
-    OrgHypercertsClaimCollection: {
+    OrgHyperboardsDisplayProfile: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.collection',
+        id: 'org.hyperboards.displayProfile',
         defs: {
             main: {
                 type: 'record',
-                description: 'A collection/group of items (activities and/or other collections). Collections support recursive nesting. Use app.certified.location as a sidecar (same TID) for location metadata.',
-                key: 'tid',
+                description: "User-declared visual presentation defaults for how a contributor appears on hyperboards. Stored in the contributor's own PDS and reusable across multiple boards.",
+                key: 'literal:self',
                 record: {
                     type: 'object',
-                    required: ['title', 'items', 'createdAt'],
+                    required: ['createdAt'],
                     properties: {
-                        type: {
+                        displayName: {
+                            type: 'string',
+                            description: 'Display name override for this user on hyperboards.',
+                            maxLength: 640,
+                            maxGraphemes: 64,
+                        },
+                        image: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: 'Avatar or face image override for this user on hyperboards, as a URI or image blob.',
+                        },
+                        video: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallVideo',
+                            ],
+                            description: 'Default video for this user across boards, as a URI (embed/direct link) or uploaded video blob.',
+                        },
+                        hoverImage: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: 'Default hover image for this user across boards, as a URI or image blob.',
+                        },
+                        hoverIframeUrl: {
                             type: 'string',
-                            description: "The type of this collection. Possible fields can be 'favorites', 'project', or any other type of collection.",
+                            format: 'uri',
+                            description: 'Default hover iframe URL for this user across boards.',
+                            maxLength: 2048,
+                        },
+                        url: {
+                            type: 'string',
+                            format: 'uri',
+                            description: 'Default click-through link URL for this user across boards.',
+                            maxLength: 2048,
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
                         },
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimActivity: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.activity',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'A hypercert record tracking impact work.',
+                key: 'any',
+                record: {
+                    type: 'object',
+                    required: ['title', 'shortDescription', 'createdAt'],
+                    properties: {
                         title: {
                             type: 'string',
-                            description: 'The title of this collection',
-                            maxLength: 800,
-                            maxGraphemes: 80,
+                            description: "Display title summarizing the impact work (e.g. 'Reforestation in Amazon Basin 2024')",
+                            maxLength: 256,
                         },
                         shortDescription: {
                             type: 'string',
+                            description: 'Short summary of this activity claim, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
                             maxLength: 3000,
                             maxGraphemes: 300,
-                            description: 'Short summary of this collection, suitable for previews and list views',
+                        },
+                        shortDescriptionFacets: {
+                            type: 'array',
+                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
+                            },
                         },
                         description: {
-                            type: 'ref',
-                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
-                            description: 'Rich-text description, represented as a Leaflet linear document.',
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#descriptionString',
+                                'lex:pub.leaflet.pages.linearDocument',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            description: 'Long-form description of the activity. An inline string for plain text or markdown, a Leaflet linear document for rich-text content, or a strong reference to an external description record.',
                         },
-                        avatar: {
+                        image: {
                             type: 'union',
                             refs: [
                                 'lex:org.hypercerts.defs#uri',
                                 'lex:org.hypercerts.defs#smallImage',
                             ],
-                            description: "The collection's avatar/profile image as a URI or image blob.",
+                            description: 'The hypercert visual representation as a URI or image blob.',
                         },
-                        banner: {
+                        contributors: {
+                            type: 'array',
+                            description: 'An array of contributor objects, each containing contributor information, weight, and contribution details.',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:org.hypercerts.claim.activity#contributor',
+                            },
+                        },
+                        workScope: {
                             type: 'union',
                             refs: [
-                                'lex:org.hypercerts.defs#uri',
-                                'lex:org.hypercerts.defs#largeImage',
+                                'lex:org.hypercerts.workscope.cel',
+                                'lex:org.hypercerts.claim.activity#workScopeString',
                             ],
-                            description: 'Larger horizontal image to display behind the collection view.',
+                            description: 'Work scope definition. A CEL expression for structured, machine-evaluable scopes or a free-form string for simple and legacy scopes.',
                         },
-                        items: {
+                        startDate: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'When the work began',
+                        },
+                        endDate: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'When the work ended',
+                        },
+                        locations: {
                             type: 'array',
-                            description: 'Array of items in this collection with optional weights.',
+                            description: 'An array of strong references to the location where activity was performed. The record referenced must conform with the lexicon app.certified.location.',
+                            maxLength: 1000,
                             items: {
                                 type: 'ref',
-                                ref: 'lex:org.hypercerts.claim.collection#item',
+                                ref: 'lex:com.atproto.repo.strongRef',
                             },
                         },
+                        rights: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'A strong reference to the rights that this hypercert has. The record referenced must conform with the lexicon org.hypercerts.claim.rights.',
+                        },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
@@ -459,26 +926,78 @@ const schemaDict = {
                     },
                 },
             },
-            item: {
+            contributor: {
                 type: 'object',
-                required: ['itemIdentifier'],
+                description: 'A contributor to the activity, with identity, weight, and contribution details.',
+                required: ['contributorIdentity'],
                 properties: {
-                    itemIdentifier: {
-                        type: 'ref',
-                        ref: 'lex:com.atproto.repo.strongRef',
-                        description: 'Strong reference to an item in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.claim.collection).',
+                    contributorIdentity: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.claim.activity#contributorIdentity',
+                            'lex:com.atproto.repo.strongRef',
+                        ],
+                        description: 'Inline contributor identity object with an identity string (DID or identifier) via org.hypercerts.claim.activity#contributorIdentity, or a strong reference to a contributor information record. The record referenced must conform with the lexicon org.hypercerts.claim.contributorInformation.',
                     },
-                    itemWeight: {
+                    contributionWeight: {
                         type: 'string',
-                        description: 'Optional weight for this item (positive numeric value stored as string). Weights do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
+                        description: 'The relative weight/importance of this contribution (stored as a string to avoid float precision issues). Must be a positive numeric value. Weights do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
+                        maxLength: 100,
+                    },
+                    contributionDetails: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.claim.activity#contributorRole',
+                            'lex:com.atproto.repo.strongRef',
+                        ],
+                        description: 'Inline contribution role object with a role string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record. The record referenced must conform with the lexicon org.hypercerts.claim.contribution.',
+                    },
+                },
+            },
+            contributorIdentity: {
+                type: 'object',
+                description: 'Contributor information as a string (DID or identifier).',
+                required: ['identity'],
+                properties: {
+                    identity: {
+                        type: 'string',
+                        description: 'The contributor identity string (DID or identifier).',
+                        maxLength: 1000,
+                        maxGraphemes: 100,
+                    },
+                },
+            },
+            contributorRole: {
+                type: 'object',
+                description: 'Contribution details as a string.',
+                required: ['role'],
+                properties: {
+                    role: {
+                        type: 'string',
+                        description: 'The contribution role or details.',
+                        maxLength: 1000,
+                        maxGraphemes: 100,
+                    },
+                },
+            },
+            workScopeString: {
+                type: 'object',
+                description: 'A free-form string describing the work scope for simple or legacy scopes.',
+                required: ['scope'],
+                properties: {
+                    scope: {
+                        type: 'string',
+                        description: 'The work scope description string.',
+                        maxLength: 1000,
+                        maxGraphemes: 100,
                     },
                 },
             },
         },
     },
-    OrgHypercertsClaimContributionDetails: {
+    OrgHypercertsClaimContribution: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.contributionDetails',
+        id: 'org.hypercerts.claim.contribution',
         defs: {
             main: {
                 type: 'record',
@@ -495,19 +1014,19 @@ const schemaDict = {
                         },
                         contributionDescription: {
                             type: 'string',
-                            description: 'What the contribution concretely was.',
+                            description: 'Description of what the contribution concretely involved.',
                             maxLength: 10000,
                             maxGraphemes: 1000,
                         },
                         startDate: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'When this contribution started. This should be a subset of the hypercert timeframe.',
+                            description: "When this contribution started. Should fall within the parent hypercert's timeframe.",
                         },
                         endDate: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'When this contribution finished. This should be a subset of the hypercert timeframe.',
+                            description: "When this contribution finished. Should fall within the parent hypercert's timeframe.",
                         },
                         createdAt: {
                             type: 'string',
@@ -533,11 +1052,12 @@ const schemaDict = {
                     properties: {
                         identifier: {
                             type: 'string',
-                            description: 'DID or a URI to a social profile of the contributor.',
+                            description: 'DID (did:plc:...) or URI to a social profile of the contributor.',
+                            maxLength: 2048,
                         },
                         displayName: {
                             type: 'string',
-                            description: 'Display name of the contributor.',
+                            description: 'Human-readable name for the contributor as it should appear in UI.',
                             maxLength: 100,
                         },
                         image: {
@@ -558,87 +1078,133 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimEvaluation: {
+    OrgHypercertsClaimRights: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.evaluation',
+        id: 'org.hypercerts.claim.rights',
         defs: {
-            score: {
-                type: 'object',
-                description: 'Overall score for an evaluation on a numeric scale.',
-                required: ['min', 'max', 'value'],
-                properties: {
-                    min: {
-                        type: 'integer',
-                        description: 'Minimum value of the scale, e.g. 0 or 1.',
-                    },
-                    max: {
-                        type: 'integer',
-                        description: 'Maximum value of the scale, e.g. 5 or 10.',
-                    },
-                    value: {
-                        type: 'integer',
-                        description: 'Score within the inclusive range [min, max].',
-                    },
+            main: {
+                type: 'record',
+                description: 'Describes the rights that a contributor and/or an owner has, such as whether the hypercert can be sold, transferred, and under what conditions.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: [
+                        'rightsName',
+                        'rightsType',
+                        'rightsDescription',
+                        'createdAt',
+                    ],
+                    properties: {
+                        rightsName: {
+                            type: 'string',
+                            description: "Human-readable name for these rights (e.g. 'All Rights Reserved', 'CC BY-SA 4.0')",
+                            maxLength: 100,
+                        },
+                        rightsType: {
+                            type: 'string',
+                            description: "Short identifier code for this rights type (e.g. 'ARR', 'CC-BY-SA') to facilitate filtering and search",
+                            maxLength: 10,
+                        },
+                        rightsDescription: {
+                            type: 'string',
+                            description: "Detailed explanation of the rights holders' permissions, restrictions, and conditions",
+                            maxLength: 10000,
+                            maxGraphemes: 1000,
+                        },
+                        attachment: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallBlob',
+                            ],
+                            description: 'An attachment to define the rights further, e.g. a legal document.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
                 },
             },
+        },
+    },
+    OrgHypercertsCollection: {
+        lexicon: 1,
+        id: 'org.hypercerts.collection',
+        defs: {
             main: {
                 type: 'record',
-                description: 'An evaluation of a hypercert record (e.g. an activity and its impact).',
+                description: 'A collection/group of items (activities and/or other collections). Collections support recursive nesting.',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['evaluators', 'summary', 'createdAt'],
+                    required: ['title', 'createdAt'],
                     properties: {
-                        subject: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to what is being evaluated. (e.g activity, measurement, contribution, etc.)',
+                        type: {
+                            type: 'string',
+                            description: 'The type of this collection. Values beyond the known set are permitted.',
+                            knownValues: ['favorites', 'project', 'portfolio', 'program'],
+                            maxLength: 64,
                         },
-                        evaluators: {
+                        title: {
+                            type: 'string',
+                            description: "Display name for this collection (e.g. 'Q1 2025 Impact Projects')",
+                            maxLength: 800,
+                            maxGraphemes: 80,
+                        },
+                        shortDescription: {
+                            type: 'string',
+                            maxLength: 3000,
+                            maxGraphemes: 300,
+                            description: 'Short summary of this collection, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
+                        },
+                        shortDescriptionFacets: {
                             type: 'array',
-                            description: 'DIDs of the evaluators',
+                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
                             items: {
                                 type: 'ref',
-                                ref: 'lex:app.certified.defs#did',
+                                ref: 'lex:app.bsky.richtext.facet',
                             },
-                            maxLength: 1000,
                         },
-                        content: {
-                            type: 'array',
-                            description: 'Evaluation data (URIs or blobs) containing detailed reports or methodology',
-                            items: {
-                                type: 'union',
-                                refs: [
-                                    'lex:org.hypercerts.defs#uri',
-                                    'lex:org.hypercerts.defs#smallBlob',
-                                ],
-                            },
-                            maxLength: 100,
+                        description: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#descriptionString',
+                                'lex:pub.leaflet.pages.linearDocument',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            description: 'Long-form description of the collection. An inline string for plain text or markdown, a Leaflet linear document for rich-text content, or a strong reference to an external description record.',
                         },
-                        measurements: {
+                        avatar: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: "The collection's avatar/profile image as a URI or image blob.",
+                        },
+                        banner: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#largeImage',
+                            ],
+                            description: 'Larger horizontal image to display behind the collection view.',
+                        },
+                        items: {
                             type: 'array',
-                            description: 'Optional references to the measurements that contributed to this evaluation. The record(s) referenced must conform with the lexicon org.hypercerts.claim.measurement',
+                            description: 'Array of items in this collection with optional weights.',
+                            maxLength: 1000,
                             items: {
                                 type: 'ref',
-                                ref: 'lex:com.atproto.repo.strongRef',
+                                ref: 'lex:org.hypercerts.collection#item',
                             },
-                            maxLength: 100,
-                        },
-                        summary: {
-                            type: 'string',
-                            description: 'Brief evaluation summary',
-                            maxLength: 5000,
-                            maxGraphemes: 1000,
-                        },
-                        score: {
-                            type: 'ref',
-                            ref: 'lex:org.hypercerts.claim.evaluation#score',
-                            description: 'Optional overall score for this evaluation on a numeric scale.',
                         },
                         location: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'An optional reference for georeferenced evaluations. The record referenced must conform with the lexicon app.certified.location.',
+                            description: "A strong reference to the location where this collection's activities were performed. The record referenced must conform with the lexicon app.certified.location.",
                         },
                         createdAt: {
                             type: 'string',
@@ -648,173 +1214,349 @@ const schemaDict = {
                     },
                 },
             },
+            item: {
+                type: 'object',
+                description: 'An item in a collection, with an identifier and optional weight.',
+                required: ['itemIdentifier'],
+                properties: {
+                    itemIdentifier: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                        description: 'Strong reference to an item in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.collection).',
+                    },
+                    itemWeight: {
+                        type: 'string',
+                        description: 'Optional weight for this item (positive numeric value stored as string). Weights do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
+                        maxLength: 100,
+                    },
+                },
+            },
         },
     },
-    OrgHypercertsClaimEvidence: {
+    OrgHypercertsContextAcknowledgement: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.evidence',
+        id: 'org.hypercerts.context.acknowledgement',
         defs: {
             main: {
                 type: 'record',
-                description: 'A piece of evidence related to a hypercert record (e.g. an activity, project, claim, or evaluation). Evidence may support, clarify, or challenge the referenced subject.',
+                description: "Acknowledges a record (subject) or its relationship in a context. Created in the acknowledging actor's repo to form a bidirectional link. Examples: a contributor acknowledging inclusion in an activity, an activity owner acknowledging inclusion in a collection, or a record owner acknowledging an evaluation.",
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['content', 'title', 'createdAt'],
+                    required: ['subject', 'acknowledged', 'createdAt'],
                     properties: {
                         subject: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the record this evidence relates to (e.g. an activity, project, claim, or evaluation).',
+                            description: 'The record being acknowledged (e.g. an activity, a contributor information record, an evaluation).',
                         },
-                        content: {
+                        context: {
                             type: 'union',
                             refs: [
                                 'lex:org.hypercerts.defs#uri',
-                                'lex:org.hypercerts.defs#smallBlob',
+                                'lex:com.atproto.repo.strongRef',
                             ],
-                            description: 'A piece of evidence (URI or blob) related to the subject record; it may support, clarify, or challenge a hypercert claim.',
-                        },
-                        title: {
-                            type: 'string',
-                            maxLength: 256,
-                            description: 'Title to describe the nature of the evidence.',
-                        },
-                        shortDescription: {
-                            type: 'string',
-                            maxLength: 3000,
-                            maxGraphemes: 300,
-                            description: 'Short description explaining what this evidence shows.',
+                            description: 'Context for the acknowledgement (e.g. the collection that includes an activity, or the activity that includes a contributor). A URI for a lightweight reference or a strong reference for content-hash verification.',
                         },
-                        description: {
-                            type: 'string',
-                            description: 'Longer description describing the evidence in more detail.',
-                            maxLength: 30000,
-                            maxGraphemes: 3000,
+                        acknowledged: {
+                            type: 'boolean',
+                            description: 'Whether the relationship is acknowledged (true) or rejected (false).',
                         },
-                        relationType: {
+                        comment: {
                             type: 'string',
-                            description: 'How this evidence relates to the subject.',
-                            knownValues: ['supports', 'challenges', 'clarifies'],
+                            description: 'Optional plain-text comment providing additional context or reasoning.',
+                            maxLength: 10000,
+                            maxGraphemes: 1000,
                         },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'Client-declared timestamp when this record was originally created',
+                            description: 'Client-declared timestamp when this record was originally created.',
                         },
                     },
                 },
             },
         },
     },
-    OrgHypercertsClaimMeasurement: {
+    OrgHypercertsContextAttachment: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.measurement',
+        id: 'org.hypercerts.context.attachment',
         defs: {
             main: {
                 type: 'record',
-                description: 'Measurement data related to a hypercert record (e.g. an activity and its impact).',
+                description: 'An attachment providing commentary, context, evidence, or documentary material related to a hypercert record (e.g. an activity, project, claim, or evaluation).',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['measurers', 'metric', 'value', 'createdAt'],
+                    required: ['title', 'createdAt'],
                     properties: {
-                        subject: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the record this measurement refers to (e.g. an activity, project, or claim).',
-                        },
-                        measurers: {
+                        subjects: {
                             type: 'array',
-                            description: 'DIDs of the entity (or entities) that measured this data',
+                            description: 'References to the subject(s) the attachment is connected to—this may be an activity claim, outcome claim, measurement, evaluation, or even another attachment. This is optional as the attachment can exist before the claim is recorded.',
                             items: {
                                 type: 'ref',
-                                ref: 'lex:app.certified.defs#did',
+                                ref: 'lex:com.atproto.repo.strongRef',
                             },
                             maxLength: 100,
                         },
-                        metric: {
+                        contentType: {
                             type: 'string',
-                            description: 'The metric being measured',
-                            maxLength: 500,
+                            description: 'The type of attachment. Values beyond the known set are permitted.',
+                            knownValues: [
+                                'report',
+                                'audit',
+                                'evidence',
+                                'testimonial',
+                                'methodology',
+                            ],
+                            maxLength: 64,
                         },
-                        value: {
-                            type: 'string',
-                            description: 'The measured value',
-                            maxLength: 500,
+                        content: {
+                            type: 'array',
+                            description: 'The files, documents, or external references included in this attachment record.',
+                            items: {
+                                type: 'union',
+                                refs: [
+                                    'lex:org.hypercerts.defs#uri',
+                                    'lex:org.hypercerts.defs#smallBlob',
+                                ],
+                            },
+                            maxLength: 100,
                         },
-                        methodType: {
+                        title: {
                             type: 'string',
-                            description: 'Short identifier for the measurement methodology',
-                            maxLength: 30,
+                            maxLength: 256,
+                            description: "Display title for this attachment (e.g. 'Impact Assessment Report', 'Audit Findings')",
                         },
-                        methodURI: {
+                        shortDescription: {
                             type: 'string',
-                            format: 'uri',
-                            description: 'URI to methodology documentation, standard protocol, or measurement procedure',
+                            description: 'Short summary of this attachment, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
+                            maxLength: 3000,
+                            maxGraphemes: 300,
                         },
-                        evidenceURI: {
+                        shortDescriptionFacets: {
                             type: 'array',
-                            description: 'URIs to related evidence or underlying data (e.g. org.hypercerts.claim.evidence records or raw datasets)',
+                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
                             items: {
-                                type: 'string',
-                                format: 'uri',
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
                             },
-                            maxLength: 50,
+                        },
+                        description: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#descriptionString',
+                                'lex:pub.leaflet.pages.linearDocument',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            description: 'Long-form description of the attachment. An inline string for plain text or markdown, a Leaflet linear document for rich-text content, or a strong reference to an external description record.',
                         },
                         location: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to the location where the measurement was taken. The record referenced must conform with the lexicon app.certified.location',
+                            description: "A strong reference to the location where this attachment's subject matter occurred. The record referenced must conform with the lexicon app.certified.location.",
                         },
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'Client-declared timestamp when this record was originally created',
+                            description: 'Client-declared timestamp when this record was originally created.',
                         },
                     },
                 },
             },
         },
     },
-    OrgHypercertsClaimRights: {
+    OrgHypercertsContextEvaluation: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.rights',
+        id: 'org.hypercerts.context.evaluation',
         defs: {
             main: {
                 type: 'record',
-                description: 'Describes the rights that a contributor and/or an owner has, such as whether the hypercert can be sold, transferred, and under what conditions.',
+                description: 'An evaluation of a hypercert record (e.g. an activity and its impact).',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: [
-                        'rightsName',
-                        'rightsType',
-                        'rightsDescription',
-                        'createdAt',
-                    ],
+                    required: ['evaluators', 'summary', 'createdAt'],
                     properties: {
-                        rightsName: {
-                            type: 'string',
-                            description: 'Full name of the rights',
+                        subject: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'A strong reference to what is being evaluated (e.g. activity, measurement, contribution, etc.)',
+                        },
+                        evaluators: {
+                            type: 'array',
+                            description: 'DIDs of the evaluators',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.certified.defs#did',
+                            },
+                            maxLength: 1000,
+                        },
+                        content: {
+                            type: 'array',
+                            description: 'Evaluation data (URIs or blobs) containing detailed reports or methodology',
+                            items: {
+                                type: 'union',
+                                refs: [
+                                    'lex:org.hypercerts.defs#uri',
+                                    'lex:org.hypercerts.defs#smallBlob',
+                                ],
+                            },
                             maxLength: 100,
                         },
-                        rightsType: {
-                            type: 'string',
-                            description: 'Short rights identifier for easier search',
-                            maxLength: 10,
+                        measurements: {
+                            type: 'array',
+                            description: 'Optional references to the measurements that contributed to this evaluation. The record(s) referenced must conform with the lexicon org.hypercerts.context.measurement',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:com.atproto.repo.strongRef',
+                            },
+                            maxLength: 100,
                         },
-                        rightsDescription: {
+                        summary: {
                             type: 'string',
-                            description: 'Description of the rights of this hypercert',
+                            description: 'Brief evaluation summary',
+                            maxLength: 5000,
+                            maxGraphemes: 1000,
                         },
-                        attachment: {
-                            type: 'union',
-                            refs: [
-                                'lex:org.hypercerts.defs#uri',
-                                'lex:org.hypercerts.defs#smallBlob',
-                            ],
-                            description: 'An attachment to define the rights further, e.g. a legal document.',
+                        score: {
+                            type: 'ref',
+                            ref: 'lex:org.hypercerts.context.evaluation#score',
+                            description: 'Optional overall score for this evaluation on a numeric scale.',
+                        },
+                        location: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'An optional reference for georeferenced evaluations. The record referenced must conform with the lexicon app.certified.location.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
+                        },
+                    },
+                },
+            },
+            score: {
+                type: 'object',
+                description: 'Overall score for an evaluation on a numeric scale.',
+                required: ['min', 'max', 'value'],
+                properties: {
+                    min: {
+                        type: 'string',
+                        description: "Minimum value of the scale as a numeric string (e.g. '0', '1').",
+                        maxLength: 50,
+                    },
+                    max: {
+                        type: 'string',
+                        description: "Maximum value of the scale as a numeric string (e.g. '5', '10').",
+                        maxLength: 50,
+                    },
+                    value: {
+                        type: 'string',
+                        description: "Score within the inclusive range [min, max] as a numeric string (e.g. '3.7').",
+                        maxLength: 50,
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsContextMeasurement: {
+        lexicon: 1,
+        id: 'org.hypercerts.context.measurement',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'Measurement data related to one or more records (e.g. activities, projects, etc.).',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['metric', 'unit', 'value', 'createdAt'],
+                    properties: {
+                        subjects: {
+                            type: 'array',
+                            description: 'Strong references to the records this measurement refers to (e.g. activities, projects, or claims).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:com.atproto.repo.strongRef',
+                            },
+                            maxLength: 100,
+                        },
+                        metric: {
+                            type: 'string',
+                            description: 'The metric being measured, e.g. forest area restored, number of users, etc.',
+                            maxLength: 500,
+                        },
+                        unit: {
+                            type: 'string',
+                            description: 'The unit of the measured value (e.g. kg CO₂e, hectares, %, index score).',
+                            maxLength: 50,
+                        },
+                        value: {
+                            type: 'string',
+                            description: "The measured value as a numeric string (e.g. '1234.56')",
+                            maxLength: 500,
+                        },
+                        startDate: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'The start date and time when the measurement began.',
+                        },
+                        endDate: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'The end date and time when the measurement ended. For one-time measurements, this should equal the start date.',
+                        },
+                        locations: {
+                            type: 'array',
+                            description: 'Optional geographic references related to where the measurement was taken. Each referenced record must conform with the app.certified.location lexicon.',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:com.atproto.repo.strongRef',
+                            },
+                            maxLength: 100,
+                        },
+                        methodType: {
+                            type: 'string',
+                            description: 'Short identifier for the measurement methodology',
+                            maxLength: 30,
+                        },
+                        methodURI: {
+                            type: 'string',
+                            format: 'uri',
+                            description: 'URI to methodology documentation, standard protocol, or measurement procedure',
+                        },
+                        evidenceURI: {
+                            type: 'array',
+                            description: 'URIs to related evidence or underlying data (e.g. org.hypercerts.claim.evidence records or raw datasets)',
+                            items: {
+                                type: 'string',
+                                format: 'uri',
+                            },
+                            maxLength: 50,
+                        },
+                        measurers: {
+                            type: 'array',
+                            description: 'DIDs of the entities that performed this measurement',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.certified.defs#did',
+                            },
+                            maxLength: 100,
+                        },
+                        comment: {
+                            type: 'string',
+                            description: 'Short comment of this measurement, suitable for previews and list views. Rich text annotations may be provided via `commentFacets`.',
+                            maxLength: 3000,
+                            maxGraphemes: 300,
+                        },
+                        commentFacets: {
+                            type: 'array',
+                            description: 'Rich text annotations for `comment` (mentions, URLs, hashtags, etc).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
+                            },
                         },
                         createdAt: {
                             type: 'string',
@@ -829,7 +1571,29 @@ const schemaDict = {
     OrgHypercertsDefs: {
         lexicon: 1,
         id: 'org.hypercerts.defs',
+        description: 'Common type definitions used across all Hypercerts protocols.',
         defs: {
+            descriptionString: {
+                type: 'object',
+                description: 'An inline long-form description as plain text or markdown, with optional rich-text annotations.',
+                required: ['value'],
+                properties: {
+                    value: {
+                        type: 'string',
+                        description: 'The description text (plain text or markdown).',
+                        maxLength: 250000,
+                        maxGraphemes: 25000,
+                    },
+                    facets: {
+                        type: 'array',
+                        description: 'Rich text annotations for the description (mentions, URLs, hashtags, etc).',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:app.bsky.richtext.facet',
+                        },
+                    },
+                },
+            },
             uri: {
                 type: 'object',
                 required: ['uri'],
@@ -838,7 +1602,6 @@ const schemaDict = {
                     uri: {
                         type: 'string',
                         format: 'uri',
-                        maxGraphemes: 1024,
                         description: 'URI to external data',
                     },
                 },
@@ -882,6 +1645,19 @@ const schemaDict = {
                     },
                 },
             },
+            smallVideo: {
+                type: 'object',
+                required: ['video'],
+                description: 'Object containing a small video',
+                properties: {
+                    video: {
+                        type: 'blob',
+                        accept: ['video/mp4', 'video/webm'],
+                        maxSize: 20971520,
+                        description: 'Video (up to 20MB)',
+                    },
+                },
+            },
             largeImage: {
                 type: 'object',
                 required: ['image'],
@@ -895,94 +1671,6 @@ const schemaDict = {
                     },
                 },
             },
-            workScopeAll: {
-                type: 'object',
-                required: ['op', 'args'],
-                description: 'Logical AND operation: all arguments must be satisfied.',
-                properties: {
-                    op: {
-                        type: 'string',
-                        const: 'all',
-                        description: "Operator type: 'all' (logical AND)",
-                    },
-                    args: {
-                        type: 'array',
-                        items: {
-                            type: 'union',
-                            refs: [
-                                'lex:org.hypercerts.defs#workScopeAll',
-                                'lex:org.hypercerts.defs#workScopeAny',
-                                'lex:org.hypercerts.defs#workScopeNot',
-                                'lex:org.hypercerts.defs#workScopeAtom',
-                            ],
-                        },
-                        minLength: 1,
-                        maxLength: 100,
-                        description: 'Array of work scope expressions that must all be satisfied',
-                    },
-                },
-            },
-            workScopeAny: {
-                type: 'object',
-                required: ['op', 'args'],
-                description: 'Logical OR operation: at least one argument must be satisfied.',
-                properties: {
-                    op: {
-                        type: 'string',
-                        const: 'any',
-                        description: "Operator type: 'any' (logical OR)",
-                    },
-                    args: {
-                        type: 'array',
-                        items: {
-                            type: 'union',
-                            refs: [
-                                'lex:org.hypercerts.defs#workScopeAll',
-                                'lex:org.hypercerts.defs#workScopeAny',
-                                'lex:org.hypercerts.defs#workScopeNot',
-                                'lex:org.hypercerts.defs#workScopeAtom',
-                            ],
-                        },
-                        minLength: 1,
-                        maxLength: 100,
-                        description: 'Array of work scope expressions, at least one of which must be satisfied',
-                    },
-                },
-            },
-            workScopeNot: {
-                type: 'object',
-                required: ['op', 'arg'],
-                description: 'Logical NOT operation: the argument must not be satisfied.',
-                properties: {
-                    op: {
-                        type: 'string',
-                        const: 'not',
-                        description: "Operator type: 'not' (logical NOT)",
-                    },
-                    arg: {
-                        type: 'union',
-                        refs: [
-                            'lex:org.hypercerts.defs#workScopeAll',
-                            'lex:org.hypercerts.defs#workScopeAny',
-                            'lex:org.hypercerts.defs#workScopeNot',
-                            'lex:org.hypercerts.defs#workScopeAtom',
-                        ],
-                        description: 'Work scope expression that must not be satisfied',
-                    },
-                },
-            },
-            workScopeAtom: {
-                type: 'object',
-                required: ['atom'],
-                description: 'Atomic scope reference: a strong reference to a scope record.',
-                properties: {
-                    atom: {
-                        type: 'ref',
-                        ref: 'lex:com.atproto.repo.strongRef',
-                        description: 'Strong reference to an org.hypercerts.helper.workScopeTag record',
-                    },
-                },
-            },
         },
     },
     OrgHypercertsFundingReceipt: {
@@ -995,41 +1683,55 @@ const schemaDict = {
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['from', 'to', 'amount', 'currency', 'createdAt'],
+                    required: ['to', 'amount', 'currency', 'createdAt'],
                     properties: {
                         from: {
-                            type: 'ref',
-                            ref: 'lex:app.certified.defs#did',
-                            description: 'DID of the sender who transferred the funds. Leave empty if sender wants to stay anonymous.',
+                            type: 'union',
+                            description: 'The sender of the funds (a free-text string, an account DID, or a strong reference to a record). Optional — omit to represent anonymity.',
+                            refs: [
+                                'lex:org.hypercerts.funding.receipt#text',
+                                'lex:app.certified.defs#did',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
                         },
                         to: {
-                            type: 'string',
-                            description: 'The recipient of the funds. Can be identified by DID or a clear-text name.',
+                            type: 'union',
+                            description: 'The recipient of the funds (a free-text string, an account DID, or a strong reference to a record).',
+                            refs: [
+                                'lex:org.hypercerts.funding.receipt#text',
+                                'lex:app.certified.defs#did',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
                         },
                         amount: {
                             type: 'string',
-                            description: 'Amount of funding received.',
+                            description: "Amount of funding received as a numeric string (e.g. '1000.50').",
+                            maxLength: 50,
                         },
                         currency: {
                             type: 'string',
                             description: 'Currency of the payment (e.g. EUR, USD, ETH).',
+                            maxLength: 10,
                         },
                         paymentRail: {
                             type: 'string',
                             description: 'How the funds were transferred (e.g. bank_transfer, credit_card, onchain, cash, check, payment_processor).',
+                            maxLength: 50,
                         },
                         paymentNetwork: {
                             type: 'string',
                             description: 'Optional network within the payment rail (e.g. arbitrum, ethereum, sepa, visa, paypal).',
+                            maxLength: 50,
                         },
                         transactionId: {
                             type: 'string',
                             description: 'Identifier of the underlying payment transaction (e.g. bank reference, onchain transaction hash, or processor-specific ID). Use paymentNetwork to specify the network where applicable.',
+                            maxLength: 256,
                         },
                         for: {
-                            type: 'string',
-                            format: 'at-uri',
-                            description: 'Optional reference to the activity, project, or organization this funding relates to.',
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Optional strong reference to the activity, project, or organization this funding relates to.',
                         },
                         notes: {
                             type: 'string',
@@ -1049,38 +1751,85 @@ const schemaDict = {
                     },
                 },
             },
+            text: {
+                type: 'object',
+                description: 'A free-text string value (e.g. a display name, wallet address, or other identifier).',
+                required: ['value'],
+                properties: {
+                    value: {
+                        type: 'string',
+                        description: 'The string value.',
+                        maxLength: 2048,
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsWorkscopeCel: {
+        lexicon: 1,
+        id: 'org.hypercerts.workscope.cel',
+        defs: {
+            main: {
+                type: 'object',
+                description: "A structured, machine-evaluable work scope definition using CEL (Common Expression Language). Tags referenced in the expression correspond to org.hypercerts.workscope.tag keys. See https://github.com/google/cel-spec. Note: this is intentionally type 'object' (not 'record') so it can be directly embedded inline in union types (e.g., activity.workScope) without requiring a separate collection or strongRef indirection.",
+                required: ['expression', 'usedTags', 'version', 'createdAt'],
+                properties: {
+                    expression: {
+                        type: 'string',
+                        maxLength: 10000,
+                        maxGraphemes: 5000,
+                        description: "A CEL expression encoding the work scope conditions. Example: scope.hasAll(['mangrove_restoration', 'environmental_education']) && location.country == 'KE'",
+                    },
+                    usedTags: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                        },
+                        maxLength: 100,
+                        description: 'Strong references to org.hypercerts.workscope.tag records used in the expression. Enables fast indexing by AT-URI and provides referential integrity to the underlying tag records.',
+                    },
+                    version: {
+                        type: 'string',
+                        maxLength: 16,
+                        knownValues: ['v1'],
+                        description: 'CEL context schema version.',
+                    },
+                    createdAt: {
+                        type: 'string',
+                        format: 'datetime',
+                        description: 'Client-declared timestamp when this expression was originally created.',
+                    },
+                },
+            },
         },
     },
-    OrgHypercertsHelperWorkScopeTag: {
+    OrgHypercertsWorkscopeTag: {
         lexicon: 1,
-        id: 'org.hypercerts.helper.workScopeTag',
+        id: 'org.hypercerts.workscope.tag',
         defs: {
             main: {
                 type: 'record',
-                description: 'A reusable scope atom for work scope logic expressions. Scopes can represent topics, languages, domains, deliverables, methods, regions, tags, or other categorical labels.',
+                description: 'A reusable scope atom for work scope logic expressions. Scopes can represent topics, languages, domains, deliverables, methods, regions, tags, or other categorical labels. Tags are composed into structured expressions via CEL (Common Expression Language) on activity records.',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['createdAt', 'key', 'label'],
+                    required: ['key', 'name', 'createdAt'],
                     properties: {
-                        createdAt: {
-                            type: 'string',
-                            format: 'datetime',
-                            description: 'Client-declared timestamp when this record was originally created',
-                        },
                         key: {
                             type: 'string',
-                            description: "Lowercase, hyphenated machine-readable key for this scope (e.g., 'ipfs', 'go-lang', 'filecoin').",
+                            description: "Lowercase, underscore-separated machine-readable key for this scope (e.g., 'mangrove_restoration', 'biodiversity_monitoring'). Used as the canonical identifier in CEL expressions.",
                             maxLength: 120,
                         },
-                        label: {
+                        name: {
                             type: 'string',
-                            description: 'Human-readable label for this scope.',
+                            description: 'Human-readable name for this scope.',
                             maxLength: 200,
                         },
-                        kind: {
+                        category: {
                             type: 'string',
-                            description: 'Category type of this scope. Recommended values: topic, language, domain, method, tag.',
+                            description: 'Category type of this scope.',
+                            knownValues: ['topic', 'language', 'domain', 'method'],
                             maxLength: 50,
                         },
                         description: {
@@ -1092,7 +1841,18 @@ const schemaDict = {
                         parent: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'Optional strong reference to a parent scope record for taxonomy/hierarchy support.',
+                            description: 'Optional strong reference to a parent work scope tag record for taxonomy/hierarchy support. The record referenced must conform with the lexicon org.hypercerts.workscope.tag.',
+                        },
+                        status: {
+                            type: 'string',
+                            description: 'Lifecycle status of this tag. Communities propose tags, curators accept them, deprecated tags point to replacements via supersededBy.',
+                            knownValues: ['proposed', 'accepted', 'deprecated'],
+                            maxLength: 20,
+                        },
+                        supersededBy: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: "When status is 'deprecated', points to the replacement work scope tag record. The record referenced must conform with the lexicon org.hypercerts.workscope.tag.",
                         },
                         aliases: {
                             type: 'array',
@@ -1101,15 +1861,657 @@ const schemaDict = {
                                 maxLength: 200,
                             },
                             maxLength: 50,
-                            description: 'Optional array of alternative names or identifiers for this scope.',
+                            description: 'Alternative human-readable names for this scope (e.g., translations, abbreviations, or common synonyms). Unlike sameAs, these are plain-text labels, not links to external ontologies.',
+                        },
+                        sameAs: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                format: 'uri',
+                                maxLength: 2048,
+                            },
+                            maxLength: 20,
+                            description: 'URIs to semantically equivalent concepts in external ontologies or taxonomies (e.g., Wikidata QIDs, ENVO terms, SDG targets). Used for interoperability, not as documentation.',
                         },
-                        externalReference: {
+                        referenceDocument: {
                             type: 'union',
                             refs: [
                                 'lex:org.hypercerts.defs#uri',
                                 'lex:org.hypercerts.defs#smallBlob',
                             ],
-                            description: 'Optional external reference for this scope as a URI or blob.',
+                            description: 'Link to a governance or reference document where this work scope tag is defined and further explained.',
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksBlockquote: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.blockquote',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    plaintext: {
+                        type: 'string',
+                    },
+                    facets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksBskyPost: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.bskyPost',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['postRef'],
+                properties: {
+                    postRef: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                    },
+                    clientHost: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksButton: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.button',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['text', 'url'],
+                properties: {
+                    text: {
+                        type: 'string',
+                    },
+                    url: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksCode: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.code',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    plaintext: {
+                        type: 'string',
+                    },
+                    language: {
+                        type: 'string',
+                    },
+                    syntaxHighlightingTheme: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksHeader: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.header',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    level: {
+                        type: 'integer',
+                        minimum: 1,
+                        maximum: 6,
+                    },
+                    plaintext: {
+                        type: 'string',
+                    },
+                    facets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksHorizontalRule: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.horizontalRule',
+        defs: {
+            main: {
+                type: 'object',
+                required: [],
+                properties: {},
+            },
+        },
+    },
+    PubLeafletBlocksIframe: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.iframe',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['url'],
+                properties: {
+                    url: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                    height: {
+                        type: 'integer',
+                        minimum: 16,
+                        maximum: 1600,
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksImage: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.image',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['image', 'aspectRatio'],
+                properties: {
+                    image: {
+                        type: 'blob',
+                        accept: ['image/*'],
+                        maxSize: 1000000,
+                    },
+                    alt: {
+                        type: 'string',
+                        description: 'Alt text description of the image, for accessibility.',
+                    },
+                    aspectRatio: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.blocks.image#aspectRatio',
+                    },
+                },
+            },
+            aspectRatio: {
+                type: 'object',
+                required: ['width', 'height'],
+                properties: {
+                    width: {
+                        type: 'integer',
+                    },
+                    height: {
+                        type: 'integer',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksMath: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.math',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['tex'],
+                properties: {
+                    tex: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksOrderedList: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.orderedList',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['children'],
+                properties: {
+                    startIndex: {
+                        type: 'integer',
+                        description: 'The starting number for this ordered list. Defaults to 1 if not specified.',
+                    },
+                    children: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.orderedList#listItem',
+                        },
+                    },
+                },
+            },
+            listItem: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    checked: {
+                        type: 'boolean',
+                        description: 'If present, this item is a checklist item. true = checked, false = unchecked. If absent, this is a normal list item.',
+                    },
+                    content: {
+                        type: 'union',
+                        refs: [
+                            'lex:pub.leaflet.blocks.text',
+                            'lex:pub.leaflet.blocks.header',
+                            'lex:pub.leaflet.blocks.image',
+                        ],
+                    },
+                    children: {
+                        type: 'array',
+                        description: 'Nested ordered list items. Mutually exclusive with unorderedListChildren; if both are present, children takes precedence.',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.orderedList#listItem',
+                        },
+                    },
+                    unorderedListChildren: {
+                        type: 'ref',
+                        description: 'A nested unordered list. Mutually exclusive with children; if both are present, children takes precedence.',
+                        ref: 'lex:pub.leaflet.blocks.unorderedList',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksPage: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.page',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['id'],
+                properties: {
+                    id: {
+                        type: 'string',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksPoll: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.poll',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['pollRef'],
+                properties: {
+                    pollRef: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksText: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.text',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['plaintext'],
+                properties: {
+                    plaintext: {
+                        type: 'string',
+                    },
+                    textSize: {
+                        type: 'string',
+                        enum: ['default', 'small', 'large'],
+                    },
+                    facets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet',
+                        },
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksUnorderedList: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.unorderedList',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['children'],
+                properties: {
+                    children: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.unorderedList#listItem',
+                        },
+                    },
+                },
+            },
+            listItem: {
+                type: 'object',
+                required: ['content'],
+                properties: {
+                    checked: {
+                        type: 'boolean',
+                        description: 'If present, this item is a checklist item. true = checked, false = unchecked. If absent, this is a normal list item.',
+                    },
+                    content: {
+                        type: 'union',
+                        refs: [
+                            'lex:pub.leaflet.blocks.text',
+                            'lex:pub.leaflet.blocks.header',
+                            'lex:pub.leaflet.blocks.image',
+                        ],
+                    },
+                    children: {
+                        type: 'array',
+                        description: 'Nested unordered list items. Mutually exclusive with orderedListChildren; if both are present, children takes precedence.',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.blocks.unorderedList#listItem',
+                        },
+                    },
+                    orderedListChildren: {
+                        type: 'ref',
+                        description: 'Nested ordered list items. Mutually exclusive with children; if both are present, children takes precedence.',
+                        ref: 'lex:pub.leaflet.blocks.orderedList',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletBlocksWebsite: {
+        lexicon: 1,
+        id: 'pub.leaflet.blocks.website',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['src'],
+                properties: {
+                    previewImage: {
+                        type: 'blob',
+                        accept: ['image/*'],
+                        maxSize: 1000000,
+                    },
+                    title: {
+                        type: 'string',
+                    },
+                    description: {
+                        type: 'string',
+                    },
+                    src: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletPagesLinearDocument: {
+        lexicon: 1,
+        id: 'pub.leaflet.pages.linearDocument',
+        defs: {
+            main: {
+                type: 'object',
+                required: ['blocks'],
+                properties: {
+                    id: {
+                        type: 'string',
+                    },
+                    blocks: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.pages.linearDocument#block',
+                        },
+                    },
+                },
+            },
+            block: {
+                type: 'object',
+                required: ['block'],
+                properties: {
+                    block: {
+                        type: 'union',
+                        refs: [
+                            'lex:pub.leaflet.blocks.iframe',
+                            'lex:pub.leaflet.blocks.text',
+                            'lex:pub.leaflet.blocks.blockquote',
+                            'lex:pub.leaflet.blocks.header',
+                            'lex:pub.leaflet.blocks.image',
+                            'lex:pub.leaflet.blocks.unorderedList',
+                            'lex:pub.leaflet.blocks.orderedList',
+                            'lex:pub.leaflet.blocks.website',
+                            'lex:pub.leaflet.blocks.math',
+                            'lex:pub.leaflet.blocks.code',
+                            'lex:pub.leaflet.blocks.horizontalRule',
+                            'lex:pub.leaflet.blocks.bskyPost',
+                            'lex:pub.leaflet.blocks.page',
+                            'lex:pub.leaflet.blocks.poll',
+                            'lex:pub.leaflet.blocks.button',
+                        ],
+                    },
+                    alignment: {
+                        type: 'string',
+                        knownValues: [
+                            'lex:pub.leaflet.pages.linearDocument#textAlignLeft',
+                            'lex:pub.leaflet.pages.linearDocument#textAlignCenter',
+                            'lex:pub.leaflet.pages.linearDocument#textAlignRight',
+                            'lex:pub.leaflet.pages.linearDocument#textAlignJustify',
+                        ],
+                    },
+                },
+            },
+            textAlignLeft: {
+                type: 'token',
+            },
+            textAlignCenter: {
+                type: 'token',
+            },
+            textAlignRight: {
+                type: 'token',
+            },
+            textAlignJustify: {
+                type: 'token',
+            },
+            quote: {
+                type: 'object',
+                required: ['start', 'end'],
+                properties: {
+                    start: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.pages.linearDocument#position',
+                    },
+                    end: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.pages.linearDocument#position',
+                    },
+                },
+            },
+            position: {
+                type: 'object',
+                required: ['block', 'offset'],
+                properties: {
+                    block: {
+                        type: 'array',
+                        items: {
+                            type: 'integer',
+                        },
+                    },
+                    offset: {
+                        type: 'integer',
+                    },
+                },
+            },
+        },
+    },
+    PubLeafletRichtextFacet: {
+        lexicon: 1,
+        id: 'pub.leaflet.richtext.facet',
+        defs: {
+            main: {
+                type: 'object',
+                description: 'Annotation of a sub-string within rich text.',
+                required: ['index', 'features'],
+                properties: {
+                    index: {
+                        type: 'ref',
+                        ref: 'lex:pub.leaflet.richtext.facet#byteSlice',
+                    },
+                    features: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:pub.leaflet.richtext.facet#link',
+                                'lex:pub.leaflet.richtext.facet#didMention',
+                                'lex:pub.leaflet.richtext.facet#atMention',
+                                'lex:pub.leaflet.richtext.facet#code',
+                                'lex:pub.leaflet.richtext.facet#highlight',
+                                'lex:pub.leaflet.richtext.facet#underline',
+                                'lex:pub.leaflet.richtext.facet#strikethrough',
+                                'lex:pub.leaflet.richtext.facet#id',
+                                'lex:pub.leaflet.richtext.facet#bold',
+                                'lex:pub.leaflet.richtext.facet#italic',
+                                'lex:pub.leaflet.richtext.facet#footnote',
+                            ],
+                        },
+                    },
+                },
+            },
+            byteSlice: {
+                type: 'object',
+                description: 'Specifies the sub-string range a facet feature applies to. Start index is inclusive, end index is exclusive. Indices are zero-indexed, counting bytes of the UTF-8 encoded text. NOTE: some languages, like Javascript, use UTF-16 or Unicode codepoints for string slice indexing; in these languages, convert to byte arrays before working with facets.',
+                required: ['byteStart', 'byteEnd'],
+                properties: {
+                    byteStart: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                    byteEnd: {
+                        type: 'integer',
+                        minimum: 0,
+                    },
+                },
+            },
+            link: {
+                type: 'object',
+                description: 'Facet feature for a URL. The text URL may have been simplified or truncated, but the facet reference should be a complete URL.',
+                required: ['uri'],
+                properties: {
+                    uri: {
+                        type: 'string',
+                    },
+                },
+            },
+            didMention: {
+                type: 'object',
+                description: 'Facet feature for mentioning a did.',
+                required: ['did'],
+                properties: {
+                    did: {
+                        type: 'string',
+                        format: 'did',
+                    },
+                },
+            },
+            atMention: {
+                type: 'object',
+                description: 'Facet feature for mentioning an AT URI.',
+                required: ['atURI'],
+                properties: {
+                    atURI: {
+                        type: 'string',
+                        format: 'uri',
+                    },
+                },
+            },
+            code: {
+                type: 'object',
+                description: 'Facet feature for inline code.',
+                required: [],
+                properties: {},
+            },
+            highlight: {
+                type: 'object',
+                description: 'Facet feature for highlighted text.',
+                required: [],
+                properties: {},
+            },
+            underline: {
+                type: 'object',
+                description: 'Facet feature for underline markup',
+                required: [],
+                properties: {},
+            },
+            strikethrough: {
+                type: 'object',
+                description: 'Facet feature for strikethrough markup',
+                required: [],
+                properties: {},
+            },
+            id: {
+                type: 'object',
+                description: 'Facet feature for an identifier. Used for linking to a segment',
+                required: [],
+                properties: {
+                    id: {
+                        type: 'string',
+                    },
+                },
+            },
+            bold: {
+                type: 'object',
+                description: 'Facet feature for bold text',
+                required: [],
+                properties: {},
+            },
+            italic: {
+                type: 'object',
+                description: 'Facet feature for italic text',
+                required: [],
+                properties: {},
+            },
+            footnote: {
+                type: 'object',
+                description: 'Facet feature for a footnote reference',
+                required: ['footnoteId', 'contentPlaintext'],
+                properties: {
+                    footnoteId: {
+                        type: 'string',
+                    },
+                    contentPlaintext: {
+                        type: 'string',
+                    },
+                    contentFacets: {
+                        type: 'array',
+                        items: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.richtext.facet#main',
                         },
                     },
                 },
@@ -1128,23 +2530,48 @@ function validate(v, id, hash, requiredType) {
         };
 }
 const ids = {
+    AppBskyRichtextFacet: 'app.bsky.richtext.facet',
+    AppCertifiedActorOrganization: 'app.certified.actor.organization',
+    AppCertifiedActorProfile: 'app.certified.actor.profile',
     AppCertifiedBadgeAward: 'app.certified.badge.award',
     AppCertifiedBadgeDefinition: 'app.certified.badge.definition',
     AppCertifiedBadgeResponse: 'app.certified.badge.response',
     AppCertifiedDefs: 'app.certified.defs',
+    AppCertifiedLinkEvm: 'app.certified.link.evm',
     AppCertifiedLocation: 'app.certified.location',
     ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
+    OrgHyperboardsBoard: 'org.hyperboards.board',
+    OrgHyperboardsDisplayProfile: 'org.hyperboards.displayProfile',
     OrgHypercertsClaimActivity: 'org.hypercerts.claim.activity',
-    OrgHypercertsClaimCollection: 'org.hypercerts.claim.collection',
-    OrgHypercertsClaimContributionDetails: 'org.hypercerts.claim.contributionDetails',
+    OrgHypercertsClaimContribution: 'org.hypercerts.claim.contribution',
     OrgHypercertsClaimContributorInformation: 'org.hypercerts.claim.contributorInformation',
-    OrgHypercertsClaimEvaluation: 'org.hypercerts.claim.evaluation',
-    OrgHypercertsClaimEvidence: 'org.hypercerts.claim.evidence',
-    OrgHypercertsClaimMeasurement: 'org.hypercerts.claim.measurement',
     OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
+    OrgHypercertsCollection: 'org.hypercerts.collection',
+    OrgHypercertsContextAcknowledgement: 'org.hypercerts.context.acknowledgement',
+    OrgHypercertsContextAttachment: 'org.hypercerts.context.attachment',
+    OrgHypercertsContextEvaluation: 'org.hypercerts.context.evaluation',
+    OrgHypercertsContextMeasurement: 'org.hypercerts.context.measurement',
     OrgHypercertsDefs: 'org.hypercerts.defs',
     OrgHypercertsFundingReceipt: 'org.hypercerts.funding.receipt',
-    OrgHypercertsHelperWorkScopeTag: 'org.hypercerts.helper.workScopeTag',
+    OrgHypercertsWorkscopeCel: 'org.hypercerts.workscope.cel',
+    OrgHypercertsWorkscopeTag: 'org.hypercerts.workscope.tag',
+    PubLeafletBlocksBlockquote: 'pub.leaflet.blocks.blockquote',
+    PubLeafletBlocksBskyPost: 'pub.leaflet.blocks.bskyPost',
+    PubLeafletBlocksButton: 'pub.leaflet.blocks.button',
+    PubLeafletBlocksCode: 'pub.leaflet.blocks.code',
+    PubLeafletBlocksHeader: 'pub.leaflet.blocks.header',
+    PubLeafletBlocksHorizontalRule: 'pub.leaflet.blocks.horizontalRule',
+    PubLeafletBlocksIframe: 'pub.leaflet.blocks.iframe',
+    PubLeafletBlocksImage: 'pub.leaflet.blocks.image',
+    PubLeafletBlocksMath: 'pub.leaflet.blocks.math',
+    PubLeafletBlocksOrderedList: 'pub.leaflet.blocks.orderedList',
+    PubLeafletBlocksPage: 'pub.leaflet.blocks.page',
+    PubLeafletBlocksPoll: 'pub.leaflet.blocks.poll',
+    PubLeafletBlocksText: 'pub.leaflet.blocks.text',
+    PubLeafletBlocksUnorderedList: 'pub.leaflet.blocks.unorderedList',
+    PubLeafletBlocksWebsite: 'pub.leaflet.blocks.website',
+    PubLeafletPagesLinearDocument: 'pub.leaflet.pages.linearDocument',
+    PubLeafletRichtextFacet: 'pub.leaflet.richtext.facet',
 };
 
 export { ids, lexicons, schemaDict, schemas, validate };