@hypercerts-org/lexicon 0.10.0-beta.14 → 0.10.0-beta.16

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var lexicon$i = require('@atproto/lexicon');
+var lexicon$n = require('@atproto/lexicon');
 
 /**
  * GENERATED CODE - DO NOT MODIFY
@@ -18,7 +18,7 @@ function is$type($type, id, hash) {
                 $type.startsWith(id) &&
                 $type.endsWith(hash);
 }
-function is$typed$i(v, id, hash) {
+function is$typed$n(v, id, hash) {
     return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
 }
 function maybe$typed(v, id, hash) {
@@ -39,19 +39,91 @@ function asPredicate(validate) {
  * GENERATED CODE - DO NOT MODIFY
  */
 const schemaDict = {
+    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 Hypercert account profile.',
+                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,
                         },
@@ -70,6 +142,7 @@ const schemaDict = {
                         website: {
                             type: 'string',
                             format: 'uri',
+                            description: 'Account website URL',
                         },
                         avatar: {
                             type: 'union',
@@ -90,6 +163,7 @@ const schemaDict = {
                         createdAt: {
                             type: 'string',
                             format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created',
                         },
                     },
                 },
@@ -124,6 +198,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',
@@ -150,10 +231,12 @@ const schemaDict = {
                         badgeType: {
                             type: 'string',
                             description: 'Category of the badge (e.g. endorsement, participation, affiliation).',
+                            maxLength: 100,
                         },
                         title: {
                             type: 'string',
                             description: 'Human-readable title of the badge.',
+                            maxLength: 256,
                         },
                         icon: {
                             type: 'blob',
@@ -169,10 +252,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',
@@ -207,12 +293,13 @@ const schemaDict = {
                         },
                         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',
@@ -275,8 +362,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: {
@@ -290,13 +386,13 @@ const schemaDict = {
                         },
                         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,
                         },
@@ -344,6 +440,234 @@ const schemaDict = {
             },
         },
     },
+    OrgHyperboardsBoard: {
+        lexicon: 1,
+        id: 'org.hyperboards.board',
+        defs: {
+            main: {
+                type: 'record',
+                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: ['subject', 'createdAt'],
+                    properties: {
+                        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.',
+                        },
+                        config: {
+                            type: 'ref',
+                            ref: 'lex:org.hyperboards.board#boardConfig',
+                            description: 'Board-level visual configuration (background, colors, aspect ratio).',
+                        },
+                        contributorConfigs: {
+                            type: 'array',
+                            description: 'Per-contributor configuration entries for this board.',
+                            maxLength: 1000,
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:org.hyperboards.board#contributorConfig',
+                            },
+                        },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
+                        },
+                    },
+                },
+            },
+            boardConfig: {
+                type: 'object',
+                description: "Visual configuration for a hyperboard's background, colors, and layout.",
+                properties: {
+                    backgroundType: {
+                        type: 'string',
+                        description: 'Type of background content.',
+                        knownValues: ['image', 'iframe'],
+                        maxLength: 10,
+                    },
+                    backgroundImage: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.defs#uri',
+                            'lex:org.hypercerts.defs#smallImage',
+                        ],
+                        description: 'Background image as a URI or image blob.',
+                    },
+                    backgroundIframeUrl: {
+                        type: 'string',
+                        format: 'uri',
+                        description: 'URI of the background iframe.',
+                        maxLength: 2048,
+                    },
+                    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: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: '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,
+                    },
+                },
+            },
+        },
+    },
+    OrgHyperboardsDisplayProfile: {
+        lexicon: 1,
+        id: 'org.hyperboards.displayProfile',
+        defs: {
+            main: {
+                type: 'record',
+                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: ['createdAt'],
+                    properties: {
+                        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',
+                            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',
@@ -358,7 +682,7 @@ const schemaDict = {
                     properties: {
                         title: {
                             type: 'string',
-                            description: 'Title of the hypercert.',
+                            description: "Display title summarizing the impact work (e.g. 'Reforestation in Amazon Basin 2024')",
                             maxLength: 256,
                         },
                         shortDescription: {
@@ -376,18 +700,9 @@ const schemaDict = {
                             },
                         },
                         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,
-                        },
-                        descriptionFacets: {
-                            type: 'array',
-                            description: 'Rich text annotations for `description` (mentions, URLs, hashtags, etc).',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:app.bsky.richtext.facet',
-                            },
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
+                            description: 'Rich-text description, represented as a Leaflet linear document.',
                         },
                         image: {
                             type: 'union',
@@ -397,13 +712,22 @@ const schemaDict = {
                             ],
                             description: 'The hypercert visual representation as a URI or image blob.',
                         },
+                        contributors: {
+                            type: 'array',
+                            description: 'An array of contributor objects, each containing contributor information, weight, and contribution details.',
+                            maxLength: 1000,
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:org.hypercerts.claim.activity#contributor',
+                            },
+                        },
                         workScope: {
                             type: 'union',
                             refs: [
-                                'lex:com.atproto.repo.strongRef',
+                                'lex:org.hypercerts.workscope.cel',
                                 'lex:org.hypercerts.claim.activity#workScopeString',
                             ],
-                            description: 'Work scope definition. Either a strongRef to a work-scope logic record (structured, nested logic), or a free-form string for simple or legacy scopes. The work scope record should conform to the org.hypercerts.helper.workScopeTag lexicon.',
+                            description: 'Work scope definition. A CEL expression for structured, machine-evaluable scopes or a free-form string for simple and legacy scopes.',
                         },
                         startDate: {
                             type: 'string',
@@ -415,12 +739,13 @@ const schemaDict = {
                             format: 'datetime',
                             description: 'When the work ended',
                         },
-                        contributors: {
+                        locations: {
                             type: 'array',
-                            description: 'An array of contributor objects, each containing contributor information, weight, and contribution details.',
+                            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.activity#contributor',
+                                ref: 'lex:com.atproto.repo.strongRef',
                             },
                         },
                         rights: {
@@ -428,14 +753,6 @@ const schemaDict = {
                             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',
@@ -454,11 +771,12 @@ const schemaDict = {
                             'lex:org.hypercerts.claim.activity#contributorIdentity',
                             'lex:com.atproto.repo.strongRef',
                         ],
-                        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: '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.',
                     },
                     contributionWeight: {
                         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.',
+                        maxLength: 100,
                     },
                     contributionDetails: {
                         type: 'union',
@@ -466,7 +784,7 @@ const schemaDict = {
                             'lex:org.hypercerts.claim.activity#contributorRole',
                             'lex:com.atproto.repo.strongRef',
                         ],
-                        description: 'Contribution details as a string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record.',
+                        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.',
                     },
                 },
             },
@@ -511,81 +829,78 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimAttachment: {
+    OrgHypercertsClaimContribution: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.attachment',
+        id: 'org.hypercerts.claim.contribution',
         defs: {
             main: {
                 type: 'record',
-                description: 'An attachment providing commentary, context, evidence, or documentary material related to a hypercert record (e.g. an activity, project, claim, or evaluation).',
+                description: 'Details about a specific contribution including role, description, and timeframe.',
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['title', 'content', 'createdAt'],
+                    required: ['createdAt'],
                     properties: {
-                        subjects: {
-                            type: 'array',
-                            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:com.atproto.repo.strongRef',
-                            },
+                        role: {
+                            type: 'string',
+                            description: 'Role or title of the contributor.',
                             maxLength: 100,
                         },
-                        contentType: {
+                        contributionDescription: {
                             type: 'string',
-                            maxLength: 64,
-                            description: 'The type of attachment, e.g. report, audit, evidence, testimonial, methodology, etc.',
+                            description: 'Description of what the contribution concretely involved.',
+                            maxLength: 10000,
+                            maxGraphemes: 1000,
                         },
-                        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,
-                        },
-                        title: {
+                        startDate: {
                             type: 'string',
-                            maxLength: 256,
-                            description: 'Title of this attachment.',
+                            format: 'datetime',
+                            description: "When this contribution started. Should fall within the parent hypercert's timeframe.",
                         },
-                        shortDescription: {
+                        endDate: {
                             type: 'string',
-                            description: 'Short summary of this attachment, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
-                            maxLength: 3000,
-                            maxGraphemes: 300,
+                            format: 'datetime',
+                            description: "When this contribution finished. Should fall within the parent hypercert's timeframe.",
                         },
-                        shortDescriptionFacets: {
-                            type: 'array',
-                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:app.bsky.richtext.facet',
-                            },
+                        createdAt: {
+                            type: 'string',
+                            format: 'datetime',
+                            description: 'Client-declared timestamp when this record was originally created.',
                         },
-                        description: {
+                    },
+                },
+            },
+        },
+    },
+    OrgHypercertsClaimContributorInformation: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.contributorInformation',
+        defs: {
+            main: {
+                type: 'record',
+                description: 'Contributor information including identifier, display name, and image.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['createdAt'],
+                    properties: {
+                        identifier: {
                             type: 'string',
-                            description: 'Optional longer description of this attachment, including context or interpretation. Rich text annotations may be provided via `descriptionFacets`.',
-                            maxLength: 30000,
-                            maxGraphemes: 3000,
+                            description: 'DID (did:plc:...) or URI to a social profile of the contributor.',
+                            maxLength: 2048,
                         },
-                        descriptionFacets: {
-                            type: 'array',
-                            description: 'Rich text annotations for `description` (mentions, URLs, hashtags, etc).',
-                            items: {
-                                type: 'ref',
-                                ref: 'lex:app.bsky.richtext.facet',
-                            },
+                        displayName: {
+                            type: 'string',
+                            description: 'Human-readable name for the contributor as it should appear in UI.',
+                            maxLength: 100,
                         },
-                        location: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            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.",
+                        image: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: 'The contributor visual representation as a URI or image blob.',
                         },
                         createdAt: {
                             type: 'string',
@@ -597,9 +912,60 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimCollection: {
+    OrgHypercertsClaimRights: {
+        lexicon: 1,
+        id: 'org.hypercerts.claim.rights',
+        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.',
+                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.claim.collection',
+        id: 'org.hypercerts.collection',
         defs: {
             main: {
                 type: 'record',
@@ -607,15 +973,16 @@ const schemaDict = {
                 key: 'tid',
                 record: {
                     type: 'object',
-                    required: ['title', 'items', 'createdAt'],
+                    required: ['title', 'createdAt'],
                     properties: {
                         type: {
                             type: 'string',
                             description: "The type of this collection. Possible fields can be 'favorites', 'project', or any other type of collection.",
+                            maxLength: 64,
                         },
                         title: {
                             type: 'string',
-                            description: 'The title of this collection',
+                            description: "Display name for this collection (e.g. 'Q1 2025 Impact Projects')",
                             maxLength: 800,
                             maxGraphemes: 80,
                         },
@@ -649,9 +1016,10 @@ const schemaDict = {
                         items: {
                             type: 'array',
                             description: 'Array of items in this collection with optional weights.',
+                            maxLength: 1000,
                             items: {
                                 type: 'ref',
-                                ref: 'lex:org.hypercerts.claim.collection#item',
+                                ref: 'lex:org.hypercerts.collection#item',
                             },
                         },
                         location: {
@@ -674,48 +1042,51 @@ const schemaDict = {
                     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).',
+                        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,
                     },
                 },
             },
         },
     },
-    OrgHypercertsClaimContributionDetails: {
+    OrgHypercertsContextAcknowledgement: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.contributionDetails',
+        id: 'org.hypercerts.context.acknowledgement',
         defs: {
             main: {
                 type: 'record',
-                description: 'Details about a specific contribution including role, description, and timeframe.',
+                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: ['createdAt'],
+                    required: ['subject', 'acknowledged', 'createdAt'],
                     properties: {
-                        role: {
-                            type: 'string',
-                            description: 'Role or title of the contributor.',
-                            maxLength: 100,
+                        subject: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'The record being acknowledged (e.g. an activity, a contributor information record, an evaluation).',
                         },
-                        contributionDescription: {
-                            type: 'string',
-                            description: 'What the contribution concretely was.',
-                            maxLength: 10000,
-                            maxGraphemes: 1000,
+                        context: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:com.atproto.repo.strongRef',
+                            ],
+                            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.',
                         },
-                        startDate: {
-                            type: 'string',
-                            format: 'datetime',
-                            description: 'When this contribution started. This should be a subset of the hypercert timeframe.',
+                        acknowledged: {
+                            type: 'boolean',
+                            description: 'Whether the relationship is acknowledged (true) or rejected (false).',
                         },
-                        endDate: {
+                        comment: {
                             type: 'string',
-                            format: 'datetime',
-                            description: 'When this contribution finished. This should be a subset of the hypercert timeframe.',
+                            description: 'Optional plain-text comment providing additional context or reasoning.',
+                            maxLength: 10000,
+                            maxGraphemes: 1000,
                         },
                         createdAt: {
                             type: 'string',
@@ -727,34 +1098,72 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimContributorInformation: {
+    OrgHypercertsContextAttachment: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.contributorInformation',
+        id: 'org.hypercerts.context.attachment',
         defs: {
             main: {
                 type: 'record',
-                description: 'Contributor information including identifier, display name, and image.',
+                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: ['createdAt'],
+                    required: ['title', 'createdAt'],
                     properties: {
-                        identifier: {
-                            type: 'string',
-                            description: 'DID or a URI to a social profile of the contributor.',
+                        subjects: {
+                            type: 'array',
+                            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:com.atproto.repo.strongRef',
+                            },
+                            maxLength: 100,
                         },
-                        displayName: {
+                        contentType: {
                             type: 'string',
-                            description: 'Display name of the contributor.',
+                            maxLength: 64,
+                            description: 'The type of attachment, e.g. report, audit, evidence, testimonial, methodology, etc.',
+                        },
+                        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,
                         },
-                        image: {
-                            type: 'union',
-                            refs: [
-                                'lex:org.hypercerts.defs#uri',
-                                'lex:org.hypercerts.defs#smallImage',
-                            ],
-                            description: 'The contributor visual representation as a URI or image blob.',
+                        title: {
+                            type: 'string',
+                            maxLength: 256,
+                            description: "Display title for this attachment (e.g. 'Impact Assessment Report', 'Audit Findings')",
+                        },
+                        shortDescription: {
+                            type: 'string',
+                            description: 'Short summary of this attachment, 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',
+                            },
+                        },
+                        description: {
+                            type: 'ref',
+                            ref: 'lex:pub.leaflet.pages.linearDocument#main',
+                            description: 'Rich-text description, represented as a Leaflet linear document.',
+                        },
+                        location: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            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',
@@ -766,29 +1175,10 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimEvaluation: {
+    OrgHypercertsContextEvaluation: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.evaluation',
+        id: 'org.hypercerts.context.evaluation',
         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: 'An evaluation of a hypercert record (e.g. an activity and its impact).',
@@ -800,7 +1190,7 @@ const schemaDict = {
                         subject: {
                             type: 'ref',
                             ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to what is being evaluated. (e.g activity, measurement, contribution, etc.)',
+                            description: 'A strong reference to what is being evaluated (e.g. activity, measurement, contribution, etc.)',
                         },
                         evaluators: {
                             type: 'array',
@@ -825,7 +1215,7 @@ const schemaDict = {
                         },
                         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.claim.measurement',
+                            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',
@@ -840,7 +1230,7 @@ const schemaDict = {
                         },
                         score: {
                             type: 'ref',
-                            ref: 'lex:org.hypercerts.claim.evaluation#score',
+                            ref: 'lex:org.hypercerts.context.evaluation#score',
                             description: 'Optional overall score for this evaluation on a numeric scale.',
                         },
                         location: {
@@ -856,24 +1246,47 @@ const schemaDict = {
                     },
                 },
             },
+            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].',
+                    },
+                },
+            },
         },
     },
-    OrgHypercertsClaimMeasurement: {
+    OrgHypercertsContextMeasurement: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.measurement',
+        id: 'org.hypercerts.context.measurement',
         defs: {
             main: {
                 type: 'record',
-                description: 'Measurement data related to a hypercert record (e.g. an activity and its impact).',
+                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: {
-                        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).',
+                        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',
@@ -887,7 +1300,7 @@ const schemaDict = {
                         },
                         value: {
                             type: 'string',
-                            description: 'The measured numeric value.',
+                            description: "The measured value as a numeric string (e.g. '1234.56')",
                             maxLength: 500,
                         },
                         startDate: {
@@ -898,7 +1311,7 @@ const schemaDict = {
                         endDate: {
                             type: 'string',
                             format: 'datetime',
-                            description: 'The end date and time when the measurement ended. If it was a one time measurement, the endDate should be equal to the startDate.',
+                            description: 'The end date and time when the measurement ended. For one-time measurements, this should equal the start date.',
                         },
                         locations: {
                             type: 'array',
@@ -930,7 +1343,7 @@ const schemaDict = {
                         },
                         measurers: {
                             type: 'array',
-                            description: 'DIDs of the entity (or entities) that measured this data',
+                            description: 'DIDs of the entities that performed this measurement',
                             items: {
                                 type: 'ref',
                                 ref: 'lex:app.certified.defs#did',
@@ -961,58 +1374,10 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsClaimRights: {
+    OrgHypercertsDefs: {
         lexicon: 1,
-        id: 'org.hypercerts.claim.rights',
-        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.',
-                key: 'tid',
-                record: {
-                    type: 'object',
-                    required: [
-                        'rightsName',
-                        'rightsType',
-                        'rightsDescription',
-                        'createdAt',
-                    ],
-                    properties: {
-                        rightsName: {
-                            type: 'string',
-                            description: 'Full name of the rights',
-                            maxLength: 100,
-                        },
-                        rightsType: {
-                            type: 'string',
-                            description: 'Short rights identifier for easier search',
-                            maxLength: 10,
-                        },
-                        rightsDescription: {
-                            type: 'string',
-                            description: 'Description of the rights of this hypercert',
-                        },
-                        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',
-                        },
-                    },
-                },
-            },
-        },
-    },
-    OrgHypercertsDefs: {
-        lexicon: 1,
-        id: 'org.hypercerts.defs',
+        id: 'org.hypercerts.defs',
+        description: 'Common type definitions used across all Hypercerts protocols.',
         defs: {
             uri: {
                 type: 'object',
@@ -1022,7 +1387,6 @@ const schemaDict = {
                     uri: {
                         type: 'string',
                         format: 'uri',
-                        maxGraphemes: 1024,
                         description: 'URI to external data',
                     },
                 },
@@ -1066,6 +1430,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'],
@@ -1101,26 +1478,32 @@ const schemaDict = {
                         to: {
                             type: 'string',
                             description: 'The recipient of the funds. Can be identified by DID or a clear-text name.',
+                            maxLength: 2048,
                         },
                         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',
@@ -1147,36 +1530,71 @@ const schemaDict = {
             },
         },
     },
-    OrgHypercertsHelperWorkScopeTag: {
+    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.',
+                    },
+                },
+            },
+        },
+    },
+    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: {
@@ -1188,7 +1606,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',
@@ -1197,15 +1626,30 @@ 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.',
                         },
                     },
                 },
@@ -1214,16 +1658,17 @@ const schemaDict = {
     },
 };
 const schemas = Object.values(schemaDict);
-const lexicons = new lexicon$i.Lexicons(schemas);
-function validate$i(v, id, hash, requiredType) {
-    return (requiredType ? is$typed$i : maybe$typed)(v, id, hash)
+const lexicons = new lexicon$n.Lexicons(schemas);
+function validate$n(v, id, hash, requiredType) {
+    return (requiredType ? is$typed$n : maybe$typed)(v, id, hash)
         ? lexicons.validate(`${id}#${hash}`, v)
         : {
             success: false,
-            error: new lexicon$i.ValidationError(`Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`),
+            error: new lexicon$n.ValidationError(`Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`),
         };
 }
 const ids = {
+    AppCertifiedActorOrganization: 'app.certified.actor.organization',
     AppCertifiedActorProfile: 'app.certified.actor.profile',
     AppCertifiedBadgeAward: 'app.certified.badge.award',
     AppCertifiedBadgeDefinition: 'app.certified.badge.definition',
@@ -1231,31 +1676,117 @@ const ids = {
     AppCertifiedDefs: 'app.certified.defs',
     AppCertifiedLocation: 'app.certified.location',
     ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
+    OrgHyperboardsBoard: 'org.hyperboards.board',
+    OrgHyperboardsDisplayProfile: 'org.hyperboards.displayProfile',
     OrgHypercertsClaimActivity: 'org.hypercerts.claim.activity',
-    OrgHypercertsClaimAttachment: 'org.hypercerts.claim.attachment',
-    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',
-    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',
 };
 
-var lexicon$h = 1;
-var id$z = "app.certified.actor.profile";
-var defs$j = {
+var lexicon$m = 1;
+var id$J = "app.certified.actor.organization";
+var defs$o = {
+	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: "#urlItem"
+					}
+				},
+				location: {
+					type: "ref",
+					ref: "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
+			}
+		}
+	}
+};
+var ACTOR_ORGANIZATION_LEXICON_JSON = {
+	lexicon: lexicon$m,
+	id: id$J,
+	defs: defs$o
+};
+
+var lexicon$l = 1;
+var id$I = "app.certified.actor.profile";
+var defs$n = {
 	main: {
 		type: "record",
-		description: "A declaration of a Hypercert account profile.",
+		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
 				},
@@ -1273,7 +1804,8 @@ var defs$j = {
 				},
 				website: {
 					type: "string",
-					format: "uri"
+					format: "uri",
+					description: "Account website URL"
 				},
 				avatar: {
 					type: "union",
@@ -1293,21 +1825,22 @@ var defs$j = {
 				},
 				createdAt: {
 					type: "string",
-					format: "datetime"
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created"
 				}
 			}
 		}
 	}
 };
 var ACTOR_PROFILE_LEXICON_JSON = {
-	lexicon: lexicon$h,
-	id: id$z,
-	defs: defs$j
+	lexicon: lexicon$l,
+	id: id$I,
+	defs: defs$n
 };
 
-var lexicon$g = 1;
-var id$y = "app.certified.badge.award";
-var defs$i = {
+var lexicon$k = 1;
+var id$H = "app.certified.badge.award";
+var defs$m = {
 	main: {
 		type: "record",
 		description: "Records a badge award to a user, project, or activity claim.",
@@ -1335,7 +1868,14 @@ var defs$i = {
 				},
 				note: {
 					type: "string",
-					description: "Optional statement explaining the reason for this badge award."
+					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",
@@ -1347,14 +1887,14 @@ var defs$i = {
 	}
 };
 var BADGE_AWARD_LEXICON_JSON = {
-	lexicon: lexicon$g,
-	id: id$y,
-	defs: defs$i
+	lexicon: lexicon$k,
+	id: id$H,
+	defs: defs$m
 };
 
-var lexicon$f = 1;
-var id$x = "app.certified.badge.definition";
-var defs$h = {
+var lexicon$j = 1;
+var id$G = "app.certified.badge.definition";
+var defs$l = {
 	main: {
 		type: "record",
 		description: "Defines a badge that can be awarded via badge award records to users, projects, or activity claims.",
@@ -1370,11 +1910,13 @@ var defs$h = {
 			properties: {
 				badgeType: {
 					type: "string",
-					description: "Category of the badge (e.g. endorsement, participation, affiliation)."
+					description: "Category of the badge (e.g. endorsement, participation, affiliation).",
+					maxLength: 100
 				},
 				title: {
 					type: "string",
-					description: "Human-readable title of the badge."
+					description: "Human-readable title of the badge.",
+					maxLength: 256
 				},
 				icon: {
 					type: "blob",
@@ -1389,11 +1931,14 @@ var defs$h = {
 				},
 				description: {
 					type: "string",
-					description: "Optional short statement describing what the badge represents."
+					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: "app.certified.defs#did"
@@ -1409,14 +1954,14 @@ var defs$h = {
 	}
 };
 var BADGE_DEFINITION_LEXICON_JSON = {
-	lexicon: lexicon$f,
-	id: id$x,
-	defs: defs$h
+	lexicon: lexicon$j,
+	id: id$G,
+	defs: defs$l
 };
 
-var lexicon$e = 1;
-var id$w = "app.certified.badge.response";
-var defs$g = {
+var lexicon$i = 1;
+var id$F = "app.certified.badge.response";
+var defs$k = {
 	main: {
 		type: "record",
 		description: "Recipient response to a badge award.",
@@ -1436,7 +1981,7 @@ var defs$g = {
 				},
 				response: {
 					type: "string",
-					"enum": [
+					knownValues: [
 						"accepted",
 						"rejected"
 					],
@@ -1444,7 +1989,8 @@ var defs$g = {
 				},
 				weight: {
 					type: "string",
-					description: "Optional relative weight for accepted badges, assigned by the recipient."
+					description: "Optional relative weight for accepted badges, assigned by the recipient.",
+					maxLength: 50
 				},
 				createdAt: {
 					type: "string",
@@ -1456,15 +2002,15 @@ var defs$g = {
 	}
 };
 var BADGE_RESPONSE_LEXICON_JSON = {
-	lexicon: lexicon$e,
-	id: id$w,
-	defs: defs$g
+	lexicon: lexicon$i,
+	id: id$F,
+	defs: defs$k
 };
 
-var lexicon$d = 1;
-var id$v = "app.certified.defs";
-var description$1 = "Common type definitions used across certified protocols.";
-var defs$f = {
+var lexicon$h = 1;
+var id$E = "app.certified.defs";
+var description$2 = "Common type definitions used across certified protocols.";
+var defs$j = {
 	did: {
 		type: "object",
 		description: "A Decentralized Identifier (DID) string.",
@@ -1482,15 +2028,15 @@ var defs$f = {
 	}
 };
 var CERTIFIED_DEFS_LEXICON_JSON = {
-	lexicon: lexicon$d,
-	id: id$v,
-	description: description$1,
-	defs: defs$f
+	lexicon: lexicon$h,
+	id: id$E,
+	description: description$2,
+	defs: defs$j
 };
 
-var lexicon$c = 1;
-var id$u = "app.certified.location";
-var defs$e = {
+var lexicon$g = 1;
+var id$D = "app.certified.location";
+var defs$i = {
 	main: {
 		type: "record",
 		description: "A location reference",
@@ -1518,10 +2064,16 @@ var defs$e = {
 				},
 				locationType: {
 					type: "string",
-					description: "An identifier for the format of the location data (e.g., 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-point",
+						"geojson",
+						"h3",
+						"geohash",
+						"wkt",
+						"address",
+						"scaledCoordinates"
 					],
 					maxLength: 20
 				},
@@ -1536,13 +2088,13 @@ var defs$e = {
 				},
 				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
 				},
@@ -1571,15 +2123,15 @@ var defs$e = {
 	}
 };
 var LOCATION_LEXICON_JSON = {
-	lexicon: lexicon$c,
-	id: id$u,
-	defs: defs$e
+	lexicon: lexicon$g,
+	id: id$D,
+	defs: defs$i
 };
 
-var lexicon$b = 1;
-var id$t = "com.atproto.repo.strongRef";
-var description = "A URI with a content-hash fingerprint.";
-var defs$d = {
+var lexicon$f = 1;
+var id$C = "com.atproto.repo.strongRef";
+var description$1 = "A URI with a content-hash fingerprint.";
+var defs$h = {
 	main: {
 		type: "object",
 		required: [
@@ -1599,75 +2151,328 @@ var defs$d = {
 	}
 };
 var STRONG_REF_LEXICON_JSON = {
-	lexicon: lexicon$b,
-	id: id$t,
-	description: description,
-	defs: defs$d
+	lexicon: lexicon$f,
+	id: id$C,
+	description: description$1,
+	defs: defs$h
 };
 
-var lexicon$a = 1;
-var id$s = "org.hypercerts.claim.activity";
-var defs$c = {
+var lexicon$e = 1;
+var id$B = "org.hyperboards.board";
+var defs$g = {
 	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",
+				"subject",
 				"createdAt"
 			],
 			properties: {
-				title: {
-					type: "string",
-					description: "Title of the hypercert.",
-					maxLength: 256
+				subject: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "Reference to the org.hypercerts.claim.activity or org.hypercerts.claim.collection this board visualizes."
 				},
-				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
+				config: {
+					type: "ref",
+					ref: "#boardConfig",
+					description: "Board-level visual configuration (background, colors, aspect ratio)."
 				},
-				shortDescriptionFacets: {
+				contributorConfigs: {
 					type: "array",
-					description: "Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).",
+					description: "Per-contributor configuration entries for this board.",
+					maxLength: 1000,
 					items: {
 						type: "ref",
-						ref: "app.bsky.richtext.facet"
+						ref: "#contributorConfig"
 					}
 				},
-				description: {
+				createdAt: {
 					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
-				},
-				descriptionFacets: {
-					type: "array",
-					description: "Rich text annotations for `description` (mentions, URLs, hashtags, etc).",
-					items: {
-						type: "ref",
-						ref: "app.bsky.richtext.facet"
-					}
-				},
-				image: {
-					type: "union",
-					refs: [
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created."
+				}
+			}
+		}
+	},
+	boardConfig: {
+		type: "object",
+		description: "Visual configuration for a hyperboard's background, colors, and layout.",
+		properties: {
+			backgroundType: {
+				type: "string",
+				description: "Type of background content.",
+				knownValues: [
+					"image",
+					"iframe"
+				],
+				maxLength: 10
+			},
+			backgroundImage: {
+				type: "union",
+				refs: [
+					"org.hypercerts.defs#uri",
+					"org.hypercerts.defs#smallImage"
+				],
+				description: "Background image as a URI or image blob."
+			},
+			backgroundIframeUrl: {
+				type: "string",
+				format: "uri",
+				description: "URI of the background iframe.",
+				maxLength: 2048
+			},
+			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: [
+					"com.atproto.repo.strongRef",
+					"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: [
+					"org.hypercerts.defs#uri",
+					"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: [
+					"org.hypercerts.defs#uri",
+					"org.hypercerts.defs#smallVideo"
+				],
+				description: "Video for this contributor, as a URI (embed/direct link) or uploaded video blob."
+			},
+			hoverImage: {
+				type: "union",
+				refs: [
+					"org.hypercerts.defs#uri",
+					"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
+			}
+		}
+	}
+};
+var HYPERBOARDS_BOARD_LEXICON_JSON = {
+	lexicon: lexicon$e,
+	id: id$B,
+	defs: defs$g
+};
+
+var lexicon$d = 1;
+var id$A = "org.hyperboards.displayProfile";
+var defs$f = {
+	main: {
+		type: "record",
+		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: [
+				"createdAt"
+			],
+			properties: {
+				displayName: {
+					type: "string",
+					description: "Display name override for this user on hyperboards.",
+					maxLength: 640,
+					maxGraphemes: 64
+				},
+				image: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"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: [
+						"org.hypercerts.defs#uri",
+						"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: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallImage"
+					],
+					description: "Default hover image for this user across boards, as a URI or image blob."
+				},
+				hoverIframeUrl: {
+					type: "string",
+					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."
+				}
+			}
+		}
+	}
+};
+var HYPERBOARDS_DISPLAY_PROFILE_LEXICON_JSON = {
+	lexicon: lexicon$d,
+	id: id$A,
+	defs: defs$f
+};
+
+var lexicon$c = 1;
+var id$z = "org.hypercerts.claim.activity";
+var defs$e = {
+	main: {
+		type: "record",
+		description: "A hypercert record tracking impact work.",
+		key: "any",
+		record: {
+			type: "object",
+			required: [
+				"title",
+				"shortDescription",
+				"createdAt"
+			],
+			properties: {
+				title: {
+					type: "string",
+					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
+				},
+				shortDescriptionFacets: {
+					type: "array",
+					description: "Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).",
+					items: {
+						type: "ref",
+						ref: "app.bsky.richtext.facet"
+					}
+				},
+				description: {
+					type: "ref",
+					ref: "pub.leaflet.pages.linearDocument#main",
+					description: "Rich-text description, represented as a Leaflet linear document."
+				},
+				image: {
+					type: "union",
+					refs: [
 						"org.hypercerts.defs#uri",
 						"org.hypercerts.defs#smallImage"
 					],
 					description: "The hypercert visual representation as a URI or image blob."
 				},
+				contributors: {
+					type: "array",
+					description: "An array of contributor objects, each containing contributor information, weight, and contribution details.",
+					maxLength: 1000,
+					items: {
+						type: "ref",
+						ref: "#contributor"
+					}
+				},
 				workScope: {
 					type: "union",
 					refs: [
-						"com.atproto.repo.strongRef",
+						"org.hypercerts.workscope.cel",
 						"#workScopeString"
 					],
-					description: "Work scope definition. Either a strongRef to a work-scope logic record (structured, nested logic), or a free-form string for simple or legacy scopes. The work scope record should conform to the org.hypercerts.helper.workScopeTag lexicon."
+					description: "Work scope definition. A CEL expression for structured, machine-evaluable scopes or a free-form string for simple and legacy scopes."
 				},
 				startDate: {
 					type: "string",
@@ -1679,12 +2484,13 @@ var defs$c = {
 					format: "datetime",
 					description: "When the work ended"
 				},
-				contributors: {
+				locations: {
 					type: "array",
-					description: "An array of contributor objects, each containing contributor information, weight, and contribution details.",
+					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: "#contributor"
+						ref: "com.atproto.repo.strongRef"
 					}
 				},
 				rights: {
@@ -1692,14 +2498,6 @@ var defs$c = {
 					ref: "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: "com.atproto.repo.strongRef"
-					}
-				},
 				createdAt: {
 					type: "string",
 					format: "datetime",
@@ -1720,11 +2518,12 @@ var defs$c = {
 					"#contributorIdentity",
 					"com.atproto.repo.strongRef"
 				],
-				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: "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."
 			},
 			contributionWeight: {
 				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."
+				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",
@@ -1732,7 +2531,7 @@ var defs$c = {
 					"#contributorRole",
 					"com.atproto.repo.strongRef"
 				],
-				description: "Contribution details as a string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record."
+				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."
 			}
 		}
 	},
@@ -1783,107 +2582,163 @@ var defs$c = {
 	}
 };
 var ACTIVITY_LEXICON_JSON = {
-	lexicon: lexicon$a,
-	id: id$s,
-	defs: defs$c
+	lexicon: lexicon$c,
+	id: id$z,
+	defs: defs$e
 };
 
-var lexicon$9 = 1;
-var id$r = "org.hypercerts.claim.attachment";
-var defs$b = {
+var lexicon$b = 1;
+var id$y = "org.hypercerts.claim.contribution";
+var defs$d = {
 	main: {
 		type: "record",
-		description: "An attachment providing commentary, context, evidence, or documentary material related to a hypercert record (e.g. an activity, project, claim, or evaluation).",
+		description: "Details about a specific contribution including role, description, and timeframe.",
 		key: "tid",
 		record: {
 			type: "object",
 			required: [
-				"title",
-				"content",
 				"createdAt"
 			],
 			properties: {
-				subjects: {
-					type: "array",
-					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: "com.atproto.repo.strongRef"
-					},
+				role: {
+					type: "string",
+					description: "Role or title of the contributor.",
 					maxLength: 100
 				},
-				contentType: {
+				contributionDescription: {
 					type: "string",
-					maxLength: 64,
-					description: "The type of attachment, e.g. report, audit, evidence, testimonial, methodology, etc."
+					description: "Description of what the contribution concretely involved.",
+					maxLength: 10000,
+					maxGraphemes: 1000
 				},
-				content: {
-					type: "array",
-					description: "The files, documents, or external references included in this attachment record.",
-					items: {
-						type: "union",
-						refs: [
-							"org.hypercerts.defs#uri",
-							"org.hypercerts.defs#smallBlob"
-						]
-					},
-					maxLength: 100
+				startDate: {
+					type: "string",
+					format: "datetime",
+					description: "When this contribution started. Should fall within the parent hypercert's timeframe."
 				},
-				title: {
+				endDate: {
 					type: "string",
-					maxLength: 256,
-					description: "Title of this attachment."
+					format: "datetime",
+					description: "When this contribution finished. Should fall within the parent hypercert's timeframe."
 				},
-				shortDescription: {
+				createdAt: {
 					type: "string",
-					description: "Short summary of this attachment, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.",
-					maxLength: 3000,
-					maxGraphemes: 300
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created."
+				}
+			}
+		}
+	}
+};
+var CONTRIBUTION_LEXICON_JSON = {
+	lexicon: lexicon$b,
+	id: id$y,
+	defs: defs$d
+};
+
+var lexicon$a = 1;
+var id$x = "org.hypercerts.claim.contributorInformation";
+var defs$c = {
+	main: {
+		type: "record",
+		description: "Contributor information including identifier, display name, and image.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"createdAt"
+			],
+			properties: {
+				identifier: {
+					type: "string",
+					description: "DID (did:plc:...) or URI to a social profile of the contributor.",
+					maxLength: 2048
 				},
-				shortDescriptionFacets: {
-					type: "array",
-					description: "Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).",
-					items: {
-						type: "ref",
-						ref: "app.bsky.richtext.facet"
-					}
+				displayName: {
+					type: "string",
+					description: "Human-readable name for the contributor as it should appear in UI.",
+					maxLength: 100
+				},
+				image: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallImage"
+					],
+					description: "The contributor visual representation as a URI or image blob."
+				},
+				createdAt: {
+					type: "string",
+					format: "datetime",
+					description: "Client-declared timestamp when this record was originally created."
+				}
+			}
+		}
+	}
+};
+var CONTRIBUTOR_INFORMATION_LEXICON_JSON = {
+	lexicon: lexicon$a,
+	id: id$x,
+	defs: defs$c
+};
+
+var lexicon$9 = 1;
+var id$w = "org.hypercerts.claim.rights";
+var defs$b = {
+	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
 				},
-				description: {
+				rightsType: {
 					type: "string",
-					description: "Optional longer description of this attachment, including context or interpretation. Rich text annotations may be provided via `descriptionFacets`.",
-					maxLength: 30000,
-					maxGraphemes: 3000
+					description: "Short identifier code for this rights type (e.g. 'ARR', 'CC-BY-SA') to facilitate filtering and search",
+					maxLength: 10
 				},
-				descriptionFacets: {
-					type: "array",
-					description: "Rich text annotations for `description` (mentions, URLs, hashtags, etc).",
-					items: {
-						type: "ref",
-						ref: "app.bsky.richtext.facet"
-					}
+				rightsDescription: {
+					type: "string",
+					description: "Detailed explanation of the rights holders' permissions, restrictions, and conditions",
+					maxLength: 10000,
+					maxGraphemes: 1000
 				},
-				location: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					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."
+				attachment: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"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."
+					description: "Client-declared timestamp when this record was originally created"
 				}
 			}
 		}
 	}
 };
-var ATTACHMENT_LEXICON_JSON = {
+var RIGHTS_LEXICON_JSON = {
 	lexicon: lexicon$9,
-	id: id$r,
+	id: id$w,
 	defs: defs$b
 };
 
 var lexicon$8 = 1;
-var id$q = "org.hypercerts.claim.collection";
+var id$v = "org.hypercerts.collection";
 var defs$a = {
 	main: {
 		type: "record",
@@ -1893,17 +2748,17 @@ var defs$a = {
 			type: "object",
 			required: [
 				"title",
-				"items",
 				"createdAt"
 			],
 			properties: {
 				type: {
 					type: "string",
-					description: "The type of this collection. Possible fields can be 'favorites', 'project', or any other type of collection."
+					description: "The type of this collection. Possible fields can be 'favorites', 'project', or any other type of collection.",
+					maxLength: 64
 				},
 				title: {
 					type: "string",
-					description: "The title of this collection",
+					description: "Display name for this collection (e.g. 'Q1 2025 Impact Projects')",
 					maxLength: 800,
 					maxGraphemes: 80
 				},
@@ -1937,6 +2792,7 @@ var defs$a = {
 				items: {
 					type: "array",
 					description: "Array of items in this collection with optional weights.",
+					maxLength: 1000,
 					items: {
 						type: "ref",
 						ref: "#item"
@@ -1964,54 +2820,59 @@ var defs$a = {
 			itemIdentifier: {
 				type: "ref",
 				ref: "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)."
+				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."
+				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
 			}
 		}
 	}
 };
-var COLLECTION_LEXICON_JSON = {
+var HYPERCERTS_COLLECTION_LEXICON_JSON = {
 	lexicon: lexicon$8,
-	id: id$q,
+	id: id$v,
 	defs: defs$a
 };
 
 var lexicon$7 = 1;
-var id$p = "org.hypercerts.claim.contributionDetails";
+var id$u = "org.hypercerts.context.acknowledgement";
 var defs$9 = {
 	main: {
 		type: "record",
-		description: "Details about a specific contribution including role, description, and timeframe.",
+		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: [
+				"subject",
+				"acknowledged",
 				"createdAt"
 			],
 			properties: {
-				role: {
-					type: "string",
-					description: "Role or title of the contributor.",
-					maxLength: 100
+				subject: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "The record being acknowledged (e.g. an activity, a contributor information record, an evaluation)."
 				},
-				contributionDescription: {
-					type: "string",
-					description: "What the contribution concretely was.",
-					maxLength: 10000,
-					maxGraphemes: 1000
+				context: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"com.atproto.repo.strongRef"
+					],
+					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."
 				},
-				startDate: {
-					type: "string",
-					format: "datetime",
-					description: "When this contribution started. This should be a subset of the hypercert timeframe."
+				acknowledged: {
+					type: "boolean",
+					description: "Whether the relationship is acknowledged (true) or rejected (false)."
 				},
-				endDate: {
+				comment: {
 					type: "string",
-					format: "datetime",
-					description: "When this contribution finished. This should be a subset of the hypercert timeframe."
+					description: "Optional plain-text comment providing additional context or reasoning.",
+					maxLength: 10000,
+					maxGraphemes: 1000
 				},
 				createdAt: {
 					type: "string",
@@ -2022,41 +2883,80 @@ var defs$9 = {
 		}
 	}
 };
-var CONTRIBUTION_DETAILS_LEXICON_JSON = {
+var CONTEXT_ACKNOWLEDGEMENT_LEXICON_JSON = {
 	lexicon: lexicon$7,
-	id: id$p,
+	id: id$u,
 	defs: defs$9
 };
 
 var lexicon$6 = 1;
-var id$o = "org.hypercerts.claim.contributorInformation";
+var id$t = "org.hypercerts.context.attachment";
 var defs$8 = {
 	main: {
 		type: "record",
-		description: "Contributor information including identifier, display name, and image.",
+		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: [
+				"title",
 				"createdAt"
 			],
 			properties: {
-				identifier: {
-					type: "string",
-					description: "DID or a URI to a social profile of the contributor."
+				subjects: {
+					type: "array",
+					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: "com.atproto.repo.strongRef"
+					},
+					maxLength: 100
 				},
-				displayName: {
+				contentType: {
 					type: "string",
-					description: "Display name of the contributor.",
+					maxLength: 64,
+					description: "The type of attachment, e.g. report, audit, evidence, testimonial, methodology, etc."
+				},
+				content: {
+					type: "array",
+					description: "The files, documents, or external references included in this attachment record.",
+					items: {
+						type: "union",
+						refs: [
+							"org.hypercerts.defs#uri",
+							"org.hypercerts.defs#smallBlob"
+						]
+					},
 					maxLength: 100
 				},
-				image: {
-					type: "union",
-					refs: [
-						"org.hypercerts.defs#uri",
-						"org.hypercerts.defs#smallImage"
-					],
-					description: "The contributor visual representation as a URI or image blob."
+				title: {
+					type: "string",
+					maxLength: 256,
+					description: "Display title for this attachment (e.g. 'Impact Assessment Report', 'Audit Findings')"
+				},
+				shortDescription: {
+					type: "string",
+					description: "Short summary of this attachment, 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: "app.bsky.richtext.facet"
+					}
+				},
+				description: {
+					type: "ref",
+					ref: "pub.leaflet.pages.linearDocument#main",
+					description: "Rich-text description, represented as a Leaflet linear document."
+				},
+				location: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					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",
@@ -2067,38 +2967,15 @@ var defs$8 = {
 		}
 	}
 };
-var CONTRIBUTOR_INFORMATION_LEXICON_JSON = {
+var CONTEXT_ATTACHMENT_LEXICON_JSON = {
 	lexicon: lexicon$6,
-	id: id$o,
+	id: id$t,
 	defs: defs$8
 };
 
 var lexicon$5 = 1;
-var id$n = "org.hypercerts.claim.evaluation";
+var id$s = "org.hypercerts.context.evaluation";
 var defs$7 = {
-	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: "An evaluation of a hypercert record (e.g. an activity and its impact).",
@@ -2114,7 +2991,7 @@ var defs$7 = {
 				subject: {
 					type: "ref",
 					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to what is being evaluated. (e.g activity, measurement, contribution, etc.)"
+					description: "A strong reference to what is being evaluated (e.g. activity, measurement, contribution, etc.)"
 				},
 				evaluators: {
 					type: "array",
@@ -2139,7 +3016,7 @@ var defs$7 = {
 				},
 				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.claim.measurement",
+					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: "com.atproto.repo.strongRef"
@@ -2169,20 +3046,43 @@ var defs$7 = {
 				}
 			}
 		}
+	},
+	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]."
+			}
+		}
 	}
 };
-var EVALUATION_LEXICON_JSON = {
+var CONTEXT_EVALUATION_LEXICON_JSON = {
 	lexicon: lexicon$5,
-	id: id$n,
+	id: id$s,
 	defs: defs$7
 };
 
 var lexicon$4 = 1;
-var id$m = "org.hypercerts.claim.measurement";
+var id$r = "org.hypercerts.context.measurement";
 var defs$6 = {
 	main: {
 		type: "record",
-		description: "Measurement data related to a hypercert record (e.g. an activity and its impact).",
+		description: "Measurement data related to one or more records (e.g. activities, projects, etc.).",
 		key: "tid",
 		record: {
 			type: "object",
@@ -2193,10 +3093,14 @@ var defs$6 = {
 				"createdAt"
 			],
 			properties: {
-				subject: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to the record this measurement refers to (e.g. an activity, project, or claim)."
+				subjects: {
+					type: "array",
+					description: "Strong references to the records this measurement refers to (e.g. activities, projects, or claims).",
+					items: {
+						type: "ref",
+						ref: "com.atproto.repo.strongRef"
+					},
+					maxLength: 100
 				},
 				metric: {
 					type: "string",
@@ -2210,7 +3114,7 @@ var defs$6 = {
 				},
 				value: {
 					type: "string",
-					description: "The measured numeric value.",
+					description: "The measured value as a numeric string (e.g. '1234.56')",
 					maxLength: 500
 				},
 				startDate: {
@@ -2221,7 +3125,7 @@ var defs$6 = {
 				endDate: {
 					type: "string",
 					format: "datetime",
-					description: "The end date and time when the measurement ended. If it was a one time measurement, the endDate should be equal to the startDate."
+					description: "The end date and time when the measurement ended. For one-time measurements, this should equal the start date."
 				},
 				locations: {
 					type: "array",
@@ -2253,7 +3157,7 @@ var defs$6 = {
 				},
 				measurers: {
 					type: "array",
-					description: "DIDs of the entity (or entities) that measured this data",
+					description: "DIDs of the entities that performed this measurement",
 					items: {
 						type: "ref",
 						ref: "app.certified.defs#did"
@@ -2283,68 +3187,16 @@ var defs$6 = {
 		}
 	}
 };
-var MEASUREMENT_LEXICON_JSON = {
+var CONTEXT_MEASUREMENT_LEXICON_JSON = {
 	lexicon: lexicon$4,
-	id: id$m,
+	id: id$r,
 	defs: defs$6
 };
 
 var lexicon$3 = 1;
-var id$l = "org.hypercerts.claim.rights";
+var id$q = "org.hypercerts.defs";
+var description = "Common type definitions used across all Hypercerts protocols.";
 var defs$5 = {
-	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: "Full name of the rights",
-					maxLength: 100
-				},
-				rightsType: {
-					type: "string",
-					description: "Short rights identifier for easier search",
-					maxLength: 10
-				},
-				rightsDescription: {
-					type: "string",
-					description: "Description of the rights of this hypercert"
-				},
-				attachment: {
-					type: "union",
-					refs: [
-						"org.hypercerts.defs#uri",
-						"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"
-				}
-			}
-		}
-	}
-};
-var RIGHTS_LEXICON_JSON = {
-	lexicon: lexicon$3,
-	id: id$l,
-	defs: defs$5
-};
-
-var lexicon$2 = 1;
-var id$k = "org.hypercerts.defs";
-var defs$4 = {
 	uri: {
 		type: "object",
 		required: [
@@ -2355,7 +3207,6 @@ var defs$4 = {
 			uri: {
 				type: "string",
 				format: "uri",
-				maxGraphemes: 1024,
 				description: "URI to external data"
 			}
 		}
@@ -2404,13 +3255,31 @@ var defs$4 = {
 			image: {
 				type: "blob",
 				accept: [
-					"image/jpeg",
-					"image/jpg",
-					"image/png",
-					"image/webp"
+					"image/jpeg",
+					"image/jpg",
+					"image/png",
+					"image/webp"
+				],
+				maxSize: 5242880,
+				description: "Image (up to 5MB)"
+			}
+		}
+	},
+	smallVideo: {
+		type: "object",
+		required: [
+			"video"
+		],
+		description: "Object containing a small video",
+		properties: {
+			video: {
+				type: "blob",
+				accept: [
+					"video/mp4",
+					"video/webm"
 				],
-				maxSize: 5242880,
-				description: "Image (up to 5MB)"
+				maxSize: 20971520,
+				description: "Video (up to 20MB)"
 			}
 		}
 	},
@@ -2436,14 +3305,15 @@ var defs$4 = {
 	}
 };
 var HYPERCERTS_DEFS_LEXICON_JSON = {
-	lexicon: lexicon$2,
-	id: id$k,
-	defs: defs$4
+	lexicon: lexicon$3,
+	id: id$q,
+	description: description,
+	defs: defs$5
 };
 
-var lexicon$1 = 1;
-var id$j = "org.hypercerts.funding.receipt";
-var defs$3 = {
+var lexicon$2 = 1;
+var id$p = "org.hypercerts.funding.receipt";
+var defs$4 = {
 	main: {
 		type: "record",
 		description: "Records a funding receipt for a payment from one user to another user. It may be recorded by the recipient, by the sender, or by a third party. The sender may remain anonymous.",
@@ -2465,27 +3335,33 @@ var defs$3 = {
 				},
 				to: {
 					type: "string",
-					description: "The recipient of the funds. Can be identified by DID or a clear-text name."
+					description: "The recipient of the funds. Can be identified by DID or a clear-text name.",
+					maxLength: 2048
 				},
 				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)."
+					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)."
+					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)."
+					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."
+					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",
@@ -2512,44 +3388,95 @@ var defs$3 = {
 	}
 };
 var FUNDING_RECEIPT_LEXICON_JSON = {
+	lexicon: lexicon$2,
+	id: id$p,
+	defs: defs$4
+};
+
+var lexicon$1 = 1;
+var id$o = "org.hypercerts.workscope.cel";
+var defs$3 = {
+	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: "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."
+			}
+		}
+	}
+};
+var WORKSCOPE_CEL_LEXICON_JSON = {
 	lexicon: lexicon$1,
-	id: id$j,
+	id: id$o,
 	defs: defs$3
 };
 
 var lexicon = 1;
-var id$i = "org.hypercerts.helper.workScopeTag";
+var id$n = "org.hypercerts.workscope.tag";
 var defs$2 = {
 	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"
+				"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: {
@@ -2561,7 +3488,22 @@ var defs$2 = {
 				parent: {
 					type: "ref",
 					ref: "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: "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",
@@ -2570,106 +3512,148 @@ var defs$2 = {
 						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: [
 						"org.hypercerts.defs#uri",
 						"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."
 				}
 			}
 		}
 	}
 };
-var WORK_SCOPE_TAG_LEXICON_JSON = {
+var WORKSCOPE_TAG_LEXICON_JSON = {
 	lexicon: lexicon,
-	id: id$i,
+	id: id$n,
 	defs: defs$2
 };
 
-const is$typed$h = is$typed$i, validate$h = validate$i;
-const id$h = 'app.certified.actor.profile';
-const hashMain$f = 'main';
-function isMain$f(v) {
-    return is$typed$h(v, id$h, hashMain$f);
+const is$typed$m = is$typed$n, validate$m = validate$n;
+const id$m = 'app.certified.actor.organization';
+const hashMain$k = 'main';
+function isMain$k(v) {
+    return is$typed$m(v, id$m, hashMain$k);
 }
-function validateMain$f(v) {
-    return validate$h(v, id$h, hashMain$f, true);
+function validateMain$k(v) {
+    return validate$m(v, id$m, hashMain$k, true);
+}
+const hashUrlItem = 'urlItem';
+function isUrlItem(v) {
+    return is$typed$m(v, id$m, hashUrlItem);
+}
+function validateUrlItem(v) {
+    return validate$m(v, id$m, hashUrlItem);
+}
+
+var organization = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$k,
+    isRecord: isMain$k,
+    isUrlItem: isUrlItem,
+    validateMain: validateMain$k,
+    validateRecord: validateMain$k,
+    validateUrlItem: validateUrlItem
+});
+
+const is$typed$l = is$typed$n, validate$l = validate$n;
+const id$l = 'app.certified.actor.profile';
+const hashMain$j = 'main';
+function isMain$j(v) {
+    return is$typed$l(v, id$l, hashMain$j);
+}
+function validateMain$j(v) {
+    return validate$l(v, id$l, hashMain$j, true);
 }
 
 var profile = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isMain: isMain$f,
-    isRecord: isMain$f,
-    validateMain: validateMain$f,
-    validateRecord: validateMain$f
+    isMain: isMain$j,
+    isRecord: isMain$j,
+    validateMain: validateMain$j,
+    validateRecord: validateMain$j
 });
 
-const is$typed$g = is$typed$i, validate$g = validate$i;
-const id$g = 'app.certified.badge.award';
-const hashMain$e = 'main';
-function isMain$e(v) {
-    return is$typed$g(v, id$g, hashMain$e);
+const is$typed$k = is$typed$n, validate$k = validate$n;
+const id$k = 'app.certified.badge.award';
+const hashMain$i = 'main';
+function isMain$i(v) {
+    return is$typed$k(v, id$k, hashMain$i);
 }
-function validateMain$e(v) {
-    return validate$g(v, id$g, hashMain$e, true);
+function validateMain$i(v) {
+    return validate$k(v, id$k, hashMain$i, true);
 }
 
 var award = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isMain: isMain$e,
-    isRecord: isMain$e,
-    validateMain: validateMain$e,
-    validateRecord: validateMain$e
+    isMain: isMain$i,
+    isRecord: isMain$i,
+    validateMain: validateMain$i,
+    validateRecord: validateMain$i
 });
 
-const is$typed$f = is$typed$i, validate$f = validate$i;
-const id$f = 'app.certified.badge.definition';
-const hashMain$d = 'main';
-function isMain$d(v) {
-    return is$typed$f(v, id$f, hashMain$d);
+const is$typed$j = is$typed$n, validate$j = validate$n;
+const id$j = 'app.certified.badge.definition';
+const hashMain$h = 'main';
+function isMain$h(v) {
+    return is$typed$j(v, id$j, hashMain$h);
 }
-function validateMain$d(v) {
-    return validate$f(v, id$f, hashMain$d, true);
+function validateMain$h(v) {
+    return validate$j(v, id$j, hashMain$h, true);
 }
 
 var definition = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isMain: isMain$d,
-    isRecord: isMain$d,
-    validateMain: validateMain$d,
-    validateRecord: validateMain$d
+    isMain: isMain$h,
+    isRecord: isMain$h,
+    validateMain: validateMain$h,
+    validateRecord: validateMain$h
 });
 
-const is$typed$e = is$typed$i, validate$e = validate$i;
-const id$e = 'app.certified.badge.response';
-const hashMain$c = 'main';
-function isMain$c(v) {
-    return is$typed$e(v, id$e, hashMain$c);
+const is$typed$i = is$typed$n, validate$i = validate$n;
+const id$i = 'app.certified.badge.response';
+const hashMain$g = 'main';
+function isMain$g(v) {
+    return is$typed$i(v, id$i, hashMain$g);
 }
-function validateMain$c(v) {
-    return validate$e(v, id$e, hashMain$c, true);
+function validateMain$g(v) {
+    return validate$i(v, id$i, hashMain$g, true);
 }
 
 var response = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isMain: isMain$c,
-    isRecord: isMain$c,
-    validateMain: validateMain$c,
-    validateRecord: validateMain$c
+    isMain: isMain$g,
+    isRecord: isMain$g,
+    validateMain: validateMain$g,
+    validateRecord: validateMain$g
 });
 
-const is$typed$d = is$typed$i, validate$d = validate$i;
-const id$d = 'app.certified.defs';
+const is$typed$h = is$typed$n, validate$h = validate$n;
+const id$h = 'app.certified.defs';
 const hashDid = 'did';
 function isDid(v) {
-    return is$typed$d(v, id$d, hashDid);
+    return is$typed$h(v, id$h, hashDid);
 }
 function validateDid(v) {
-    return validate$d(v, id$d, hashDid);
+    return validate$h(v, id$h, hashDid);
 }
 
 var defs$1 = /*#__PURE__*/Object.freeze({
@@ -2678,85 +3662,139 @@ var defs$1 = /*#__PURE__*/Object.freeze({
     validateDid: validateDid
 });
 
-const is$typed$c = is$typed$i, validate$c = validate$i;
-const id$c = 'app.certified.location';
-const hashMain$b = 'main';
-function isMain$b(v) {
-    return is$typed$c(v, id$c, hashMain$b);
+const is$typed$g = is$typed$n, validate$g = validate$n;
+const id$g = 'app.certified.location';
+const hashMain$f = 'main';
+function isMain$f(v) {
+    return is$typed$g(v, id$g, hashMain$f);
 }
-function validateMain$b(v) {
-    return validate$c(v, id$c, hashMain$b, true);
+function validateMain$f(v) {
+    return validate$g(v, id$g, hashMain$f, true);
 }
 const hashString = 'string';
 function isString(v) {
-    return is$typed$c(v, id$c, hashString);
+    return is$typed$g(v, id$g, hashString);
 }
 function validateString(v) {
-    return validate$c(v, id$c, hashString);
+    return validate$g(v, id$g, hashString);
 }
 
 var location = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isMain: isMain$b,
-    isRecord: isMain$b,
+    isMain: isMain$f,
+    isRecord: isMain$f,
     isString: isString,
-    validateMain: validateMain$b,
-    validateRecord: validateMain$b,
+    validateMain: validateMain$f,
+    validateRecord: validateMain$f,
     validateString: validateString
 });
 
-const is$typed$b = is$typed$i, validate$b = validate$i;
-const id$b = 'com.atproto.repo.strongRef';
-const hashMain$a = 'main';
-function isMain$a(v) {
-    return is$typed$b(v, id$b, hashMain$a);
+const is$typed$f = is$typed$n, validate$f = validate$n;
+const id$f = 'com.atproto.repo.strongRef';
+const hashMain$e = 'main';
+function isMain$e(v) {
+    return is$typed$f(v, id$f, hashMain$e);
 }
-function validateMain$a(v) {
-    return validate$b(v, id$b, hashMain$a);
+function validateMain$e(v) {
+    return validate$f(v, id$f, hashMain$e);
 }
 
 var strongRef = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isMain: isMain$a,
-    validateMain: validateMain$a
+    isMain: isMain$e,
+    validateMain: validateMain$e
 });
 
-const is$typed$a = is$typed$i, validate$a = validate$i;
-const id$a = 'org.hypercerts.claim.activity';
-const hashMain$9 = 'main';
-function isMain$9(v) {
-    return is$typed$a(v, id$a, hashMain$9);
+const is$typed$e = is$typed$n, validate$e = validate$n;
+const id$e = 'org.hyperboards.board';
+const hashMain$d = 'main';
+function isMain$d(v) {
+    return is$typed$e(v, id$e, hashMain$d);
 }
-function validateMain$9(v) {
-    return validate$a(v, id$a, hashMain$9, true);
+function validateMain$d(v) {
+    return validate$e(v, id$e, hashMain$d, true);
+}
+const hashBoardConfig = 'boardConfig';
+function isBoardConfig(v) {
+    return is$typed$e(v, id$e, hashBoardConfig);
+}
+function validateBoardConfig(v) {
+    return validate$e(v, id$e, hashBoardConfig);
+}
+const hashContributorConfig = 'contributorConfig';
+function isContributorConfig(v) {
+    return is$typed$e(v, id$e, hashContributorConfig);
+}
+function validateContributorConfig(v) {
+    return validate$e(v, id$e, hashContributorConfig);
+}
+
+var board = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isBoardConfig: isBoardConfig,
+    isContributorConfig: isContributorConfig,
+    isMain: isMain$d,
+    isRecord: isMain$d,
+    validateBoardConfig: validateBoardConfig,
+    validateContributorConfig: validateContributorConfig,
+    validateMain: validateMain$d,
+    validateRecord: validateMain$d
+});
+
+const is$typed$d = is$typed$n, validate$d = validate$n;
+const id$d = 'org.hyperboards.displayProfile';
+const hashMain$c = 'main';
+function isMain$c(v) {
+    return is$typed$d(v, id$d, hashMain$c);
+}
+function validateMain$c(v) {
+    return validate$d(v, id$d, hashMain$c, true);
+}
+
+var displayProfile = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$c,
+    isRecord: isMain$c,
+    validateMain: validateMain$c,
+    validateRecord: validateMain$c
+});
+
+const is$typed$c = is$typed$n, validate$c = validate$n;
+const id$c = 'org.hypercerts.claim.activity';
+const hashMain$b = 'main';
+function isMain$b(v) {
+    return is$typed$c(v, id$c, hashMain$b);
+}
+function validateMain$b(v) {
+    return validate$c(v, id$c, hashMain$b, true);
 }
 const hashContributor = 'contributor';
 function isContributor(v) {
-    return is$typed$a(v, id$a, hashContributor);
+    return is$typed$c(v, id$c, hashContributor);
 }
 function validateContributor(v) {
-    return validate$a(v, id$a, hashContributor);
+    return validate$c(v, id$c, hashContributor);
 }
 const hashContributorIdentity = 'contributorIdentity';
 function isContributorIdentity(v) {
-    return is$typed$a(v, id$a, hashContributorIdentity);
+    return is$typed$c(v, id$c, hashContributorIdentity);
 }
 function validateContributorIdentity(v) {
-    return validate$a(v, id$a, hashContributorIdentity);
+    return validate$c(v, id$c, hashContributorIdentity);
 }
 const hashContributorRole = 'contributorRole';
 function isContributorRole(v) {
-    return is$typed$a(v, id$a, hashContributorRole);
+    return is$typed$c(v, id$c, hashContributorRole);
 }
 function validateContributorRole(v) {
-    return validate$a(v, id$a, hashContributorRole);
+    return validate$c(v, id$c, hashContributorRole);
 }
 const hashWorkScopeString = 'workScopeString';
 function isWorkScopeString(v) {
-    return is$typed$a(v, id$a, hashWorkScopeString);
+    return is$typed$c(v, id$c, hashWorkScopeString);
 }
 function validateWorkScopeString(v) {
-    return validate$a(v, id$a, hashWorkScopeString);
+    return validate$c(v, id$c, hashWorkScopeString);
 }
 
 var activity = /*#__PURE__*/Object.freeze({
@@ -2764,19 +3802,55 @@ var activity = /*#__PURE__*/Object.freeze({
     isContributor: isContributor,
     isContributorIdentity: isContributorIdentity,
     isContributorRole: isContributorRole,
-    isMain: isMain$9,
-    isRecord: isMain$9,
+    isMain: isMain$b,
+    isRecord: isMain$b,
     isWorkScopeString: isWorkScopeString,
     validateContributor: validateContributor,
     validateContributorIdentity: validateContributorIdentity,
     validateContributorRole: validateContributorRole,
-    validateMain: validateMain$9,
-    validateRecord: validateMain$9,
+    validateMain: validateMain$b,
+    validateRecord: validateMain$b,
     validateWorkScopeString: validateWorkScopeString
 });
 
-const is$typed$9 = is$typed$i, validate$9 = validate$i;
-const id$9 = 'org.hypercerts.claim.attachment';
+const is$typed$b = is$typed$n, validate$b = validate$n;
+const id$b = 'org.hypercerts.claim.contribution';
+const hashMain$a = 'main';
+function isMain$a(v) {
+    return is$typed$b(v, id$b, hashMain$a);
+}
+function validateMain$a(v) {
+    return validate$b(v, id$b, hashMain$a, true);
+}
+
+var contribution = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$a,
+    isRecord: isMain$a,
+    validateMain: validateMain$a,
+    validateRecord: validateMain$a
+});
+
+const is$typed$a = is$typed$n, validate$a = validate$n;
+const id$a = 'org.hypercerts.claim.contributorInformation';
+const hashMain$9 = 'main';
+function isMain$9(v) {
+    return is$typed$a(v, id$a, hashMain$9);
+}
+function validateMain$9(v) {
+    return validate$a(v, id$a, hashMain$9, true);
+}
+
+var contributorInformation = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$9,
+    isRecord: isMain$9,
+    validateMain: validateMain$9,
+    validateRecord: validateMain$9
+});
+
+const is$typed$9 = is$typed$n, validate$9 = validate$n;
+const id$9 = 'org.hypercerts.claim.rights';
 const hashMain$8 = 'main';
 function isMain$8(v) {
     return is$typed$9(v, id$9, hashMain$8);
@@ -2785,7 +3859,7 @@ function validateMain$8(v) {
     return validate$9(v, id$9, hashMain$8, true);
 }
 
-var attachment = /*#__PURE__*/Object.freeze({
+var rights = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$8,
     isRecord: isMain$8,
@@ -2793,8 +3867,8 @@ var attachment = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$8
 });
 
-const is$typed$8 = is$typed$i, validate$8 = validate$i;
-const id$8 = 'org.hypercerts.claim.collection';
+const is$typed$8 = is$typed$n, validate$8 = validate$n;
+const id$8 = 'org.hypercerts.collection';
 const hashMain$7 = 'main';
 function isMain$7(v) {
     return is$typed$8(v, id$8, hashMain$7);
@@ -2820,8 +3894,8 @@ var collection = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$7
 });
 
-const is$typed$7 = is$typed$i, validate$7 = validate$i;
-const id$7 = 'org.hypercerts.claim.contributionDetails';
+const is$typed$7 = is$typed$n, validate$7 = validate$n;
+const id$7 = 'org.hypercerts.context.acknowledgement';
 const hashMain$6 = 'main';
 function isMain$6(v) {
     return is$typed$7(v, id$7, hashMain$6);
@@ -2830,7 +3904,7 @@ function validateMain$6(v) {
     return validate$7(v, id$7, hashMain$6, true);
 }
 
-var contributionDetails = /*#__PURE__*/Object.freeze({
+var acknowledgement = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$6,
     isRecord: isMain$6,
@@ -2838,8 +3912,8 @@ var contributionDetails = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$6
 });
 
-const is$typed$6 = is$typed$i, validate$6 = validate$i;
-const id$6 = 'org.hypercerts.claim.contributorInformation';
+const is$typed$6 = is$typed$n, validate$6 = validate$n;
+const id$6 = 'org.hypercerts.context.attachment';
 const hashMain$5 = 'main';
 function isMain$5(v) {
     return is$typed$6(v, id$6, hashMain$5);
@@ -2848,7 +3922,7 @@ function validateMain$5(v) {
     return validate$6(v, id$6, hashMain$5, true);
 }
 
-var contributorInformation = /*#__PURE__*/Object.freeze({
+var attachment = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$5,
     isRecord: isMain$5,
@@ -2856,15 +3930,8 @@ var contributorInformation = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$5
 });
 
-const is$typed$5 = is$typed$i, validate$5 = validate$i;
-const id$5 = 'org.hypercerts.claim.evaluation';
-const hashScore = 'score';
-function isScore(v) {
-    return is$typed$5(v, id$5, hashScore);
-}
-function validateScore(v) {
-    return validate$5(v, id$5, hashScore);
-}
+const is$typed$5 = is$typed$n, validate$5 = validate$n;
+const id$5 = 'org.hypercerts.context.evaluation';
 const hashMain$4 = 'main';
 function isMain$4(v) {
     return is$typed$5(v, id$5, hashMain$4);
@@ -2872,6 +3939,13 @@ function isMain$4(v) {
 function validateMain$4(v) {
     return validate$5(v, id$5, hashMain$4, true);
 }
+const hashScore = 'score';
+function isScore(v) {
+    return is$typed$5(v, id$5, hashScore);
+}
+function validateScore(v) {
+    return validate$5(v, id$5, hashScore);
+}
 
 var evaluation = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -2883,8 +3957,8 @@ var evaluation = /*#__PURE__*/Object.freeze({
     validateScore: validateScore
 });
 
-const is$typed$4 = is$typed$i, validate$4 = validate$i;
-const id$4 = 'org.hypercerts.claim.measurement';
+const is$typed$4 = is$typed$n, validate$4 = validate$n;
+const id$4 = 'org.hypercerts.context.measurement';
 const hashMain$3 = 'main';
 function isMain$3(v) {
     return is$typed$4(v, id$4, hashMain$3);
@@ -2901,60 +3975,49 @@ var measurement = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$3
 });
 
-const is$typed$3 = is$typed$i, validate$3 = validate$i;
-const id$3 = 'org.hypercerts.claim.rights';
-const hashMain$2 = 'main';
-function isMain$2(v) {
-    return is$typed$3(v, id$3, hashMain$2);
-}
-function validateMain$2(v) {
-    return validate$3(v, id$3, hashMain$2, true);
-}
-
-var rights = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    isMain: isMain$2,
-    isRecord: isMain$2,
-    validateMain: validateMain$2,
-    validateRecord: validateMain$2
-});
-
-const is$typed$2 = is$typed$i, validate$2 = validate$i;
-const id$2 = 'org.hypercerts.defs';
+const is$typed$3 = is$typed$n, validate$3 = validate$n;
+const id$3 = 'org.hypercerts.defs';
 const hashUri = 'uri';
 function isUri(v) {
-    return is$typed$2(v, id$2, hashUri);
+    return is$typed$3(v, id$3, hashUri);
 }
 function validateUri(v) {
-    return validate$2(v, id$2, hashUri);
+    return validate$3(v, id$3, hashUri);
 }
 const hashSmallBlob = 'smallBlob';
 function isSmallBlob(v) {
-    return is$typed$2(v, id$2, hashSmallBlob);
+    return is$typed$3(v, id$3, hashSmallBlob);
 }
 function validateSmallBlob(v) {
-    return validate$2(v, id$2, hashSmallBlob);
+    return validate$3(v, id$3, hashSmallBlob);
 }
 const hashLargeBlob = 'largeBlob';
 function isLargeBlob(v) {
-    return is$typed$2(v, id$2, hashLargeBlob);
+    return is$typed$3(v, id$3, hashLargeBlob);
 }
 function validateLargeBlob(v) {
-    return validate$2(v, id$2, hashLargeBlob);
+    return validate$3(v, id$3, hashLargeBlob);
 }
 const hashSmallImage = 'smallImage';
 function isSmallImage(v) {
-    return is$typed$2(v, id$2, hashSmallImage);
+    return is$typed$3(v, id$3, hashSmallImage);
 }
 function validateSmallImage(v) {
-    return validate$2(v, id$2, hashSmallImage);
+    return validate$3(v, id$3, hashSmallImage);
+}
+const hashSmallVideo = 'smallVideo';
+function isSmallVideo(v) {
+    return is$typed$3(v, id$3, hashSmallVideo);
+}
+function validateSmallVideo(v) {
+    return validate$3(v, id$3, hashSmallVideo);
 }
 const hashLargeImage = 'largeImage';
 function isLargeImage(v) {
-    return is$typed$2(v, id$2, hashLargeImage);
+    return is$typed$3(v, id$3, hashLargeImage);
 }
 function validateLargeImage(v) {
-    return validate$2(v, id$2, hashLargeImage);
+    return validate$3(v, id$3, hashLargeImage);
 }
 
 var defs = /*#__PURE__*/Object.freeze({
@@ -2963,34 +4026,52 @@ var defs = /*#__PURE__*/Object.freeze({
     isLargeImage: isLargeImage,
     isSmallBlob: isSmallBlob,
     isSmallImage: isSmallImage,
+    isSmallVideo: isSmallVideo,
     isUri: isUri,
     validateLargeBlob: validateLargeBlob,
     validateLargeImage: validateLargeImage,
     validateSmallBlob: validateSmallBlob,
     validateSmallImage: validateSmallImage,
+    validateSmallVideo: validateSmallVideo,
     validateUri: validateUri
 });
 
-const is$typed$1 = is$typed$i, validate$1 = validate$i;
-const id$1 = 'org.hypercerts.funding.receipt';
+const is$typed$2 = is$typed$n, validate$2 = validate$n;
+const id$2 = 'org.hypercerts.funding.receipt';
+const hashMain$2 = 'main';
+function isMain$2(v) {
+    return is$typed$2(v, id$2, hashMain$2);
+}
+function validateMain$2(v) {
+    return validate$2(v, id$2, hashMain$2, true);
+}
+
+var receipt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$2,
+    isRecord: isMain$2,
+    validateMain: validateMain$2,
+    validateRecord: validateMain$2
+});
+
+const is$typed$1 = is$typed$n, validate$1 = validate$n;
+const id$1 = 'org.hypercerts.workscope.cel';
 const hashMain$1 = 'main';
 function isMain$1(v) {
     return is$typed$1(v, id$1, hashMain$1);
 }
 function validateMain$1(v) {
-    return validate$1(v, id$1, hashMain$1, true);
+    return validate$1(v, id$1, hashMain$1);
 }
 
-var receipt = /*#__PURE__*/Object.freeze({
+var cel = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$1,
-    isRecord: isMain$1,
-    validateMain: validateMain$1,
-    validateRecord: validateMain$1
+    validateMain: validateMain$1
 });
 
-const is$typed = is$typed$i, validate = validate$i;
-const id = 'org.hypercerts.helper.workScopeTag';
+const is$typed = is$typed$n, validate = validate$n;
+const id = 'org.hypercerts.workscope.tag';
 const hashMain = 'main';
 function isMain(v) {
     return is$typed(v, id, hashMain);
@@ -2999,7 +4080,7 @@ function validateMain(v) {
     return validate(v, id, hashMain, true);
 }
 
-var workScopeTag = /*#__PURE__*/Object.freeze({
+var tag = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain,
     isRecord: isMain,
@@ -3013,7 +4094,7 @@ var workScopeTag = /*#__PURE__*/Object.freeze({
  * ⚠️  DO NOT EDIT THIS FILE MANUALLY ⚠️
  *
  * This file is automatically generated by scripts/generate-exports.js
- * Generated: 2026-02-10T10:47:30.525Z
+ * Generated: 2026-03-02T17:51:18.002Z
  *
  * To regenerate this file, run:
  *   npm run gen-api
@@ -3030,6 +4111,7 @@ var workScopeTag = /*#__PURE__*/Object.freeze({
  * @packageDocumentation
  */
 // Individual NSID constants
+const ACTOR_ORGANIZATION_NSID = "app.certified.actor.organization";
 const ACTOR_PROFILE_NSID = "app.certified.actor.profile";
 const BADGE_AWARD_NSID = "app.certified.badge.award";
 const BADGE_DEFINITION_NSID = "app.certified.badge.definition";
@@ -3037,17 +4119,21 @@ const BADGE_RESPONSE_NSID = "app.certified.badge.response";
 const CERTIFIED_DEFS_NSID = "app.certified.defs";
 const LOCATION_NSID = "app.certified.location";
 const STRONG_REF_NSID = "com.atproto.repo.strongRef";
+const HYPERBOARDS_BOARD_NSID = "org.hyperboards.board";
+const HYPERBOARDS_DISPLAY_PROFILE_NSID = "org.hyperboards.displayProfile";
 const ACTIVITY_NSID = "org.hypercerts.claim.activity";
-const ATTACHMENT_NSID = "org.hypercerts.claim.attachment";
-const COLLECTION_NSID = "org.hypercerts.claim.collection";
-const CONTRIBUTION_DETAILS_NSID = "org.hypercerts.claim.contributionDetails";
+const CONTRIBUTION_NSID = "org.hypercerts.claim.contribution";
 const CONTRIBUTOR_INFORMATION_NSID = "org.hypercerts.claim.contributorInformation";
-const EVALUATION_NSID = "org.hypercerts.claim.evaluation";
-const MEASUREMENT_NSID = "org.hypercerts.claim.measurement";
 const RIGHTS_NSID = "org.hypercerts.claim.rights";
+const HYPERCERTS_COLLECTION_NSID = "org.hypercerts.collection";
+const CONTEXT_ACKNOWLEDGEMENT_NSID = "org.hypercerts.context.acknowledgement";
+const CONTEXT_ATTACHMENT_NSID = "org.hypercerts.context.attachment";
+const CONTEXT_EVALUATION_NSID = "org.hypercerts.context.evaluation";
+const CONTEXT_MEASUREMENT_NSID = "org.hypercerts.context.measurement";
 const HYPERCERTS_DEFS_NSID = "org.hypercerts.defs";
 const FUNDING_RECEIPT_NSID = "org.hypercerts.funding.receipt";
-const WORK_SCOPE_TAG_NSID = "org.hypercerts.helper.workScopeTag";
+const WORKSCOPE_CEL_NSID = "org.hypercerts.workscope.cel";
+const WORKSCOPE_TAG_NSID = "org.hypercerts.workscope.tag";
 /**
  * Collection NSIDs organized by semantic record type.
  *
@@ -3055,6 +4141,7 @@ const WORK_SCOPE_TAG_NSID = "org.hypercerts.helper.workScopeTag";
  * correct collection names.
  */
 const HYPERCERTS_NSIDS = {
+    ACTOR_ORGANIZATION: ACTOR_ORGANIZATION_NSID,
     ACTOR_PROFILE: ACTOR_PROFILE_NSID,
     BADGE_AWARD: BADGE_AWARD_NSID,
     BADGE_DEFINITION: BADGE_DEFINITION_NSID,
@@ -3062,22 +4149,27 @@ const HYPERCERTS_NSIDS = {
     CERTIFIED_DEFS: CERTIFIED_DEFS_NSID,
     LOCATION: LOCATION_NSID,
     STRONG_REF: STRONG_REF_NSID,
+    HYPERBOARDS_BOARD: HYPERBOARDS_BOARD_NSID,
+    HYPERBOARDS_DISPLAY_PROFILE: HYPERBOARDS_DISPLAY_PROFILE_NSID,
     ACTIVITY: ACTIVITY_NSID,
-    ATTACHMENT: ATTACHMENT_NSID,
-    COLLECTION: COLLECTION_NSID,
-    CONTRIBUTION_DETAILS: CONTRIBUTION_DETAILS_NSID,
+    CONTRIBUTION: CONTRIBUTION_NSID,
     CONTRIBUTOR_INFORMATION: CONTRIBUTOR_INFORMATION_NSID,
-    EVALUATION: EVALUATION_NSID,
-    MEASUREMENT: MEASUREMENT_NSID,
     RIGHTS: RIGHTS_NSID,
+    HYPERCERTS_COLLECTION: HYPERCERTS_COLLECTION_NSID,
+    CONTEXT_ACKNOWLEDGEMENT: CONTEXT_ACKNOWLEDGEMENT_NSID,
+    CONTEXT_ATTACHMENT: CONTEXT_ATTACHMENT_NSID,
+    CONTEXT_EVALUATION: CONTEXT_EVALUATION_NSID,
+    CONTEXT_MEASUREMENT: CONTEXT_MEASUREMENT_NSID,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_NSID,
     FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
-    WORK_SCOPE_TAG: WORK_SCOPE_TAG_NSID,
+    WORKSCOPE_CEL: WORKSCOPE_CEL_NSID,
+    WORKSCOPE_TAG: WORKSCOPE_TAG_NSID,
 };
 /**
  * Lexicon JSON objects organized by semantic record type.
  */
 const HYPERCERTS_LEXICON_JSON = {
+    ACTOR_ORGANIZATION: ACTOR_ORGANIZATION_LEXICON_JSON,
     ACTOR_PROFILE: ACTOR_PROFILE_LEXICON_JSON,
     BADGE_AWARD: BADGE_AWARD_LEXICON_JSON,
     BADGE_DEFINITION: BADGE_DEFINITION_LEXICON_JSON,
@@ -3085,19 +4177,24 @@ const HYPERCERTS_LEXICON_JSON = {
     CERTIFIED_DEFS: CERTIFIED_DEFS_LEXICON_JSON,
     LOCATION: LOCATION_LEXICON_JSON,
     STRONG_REF: STRONG_REF_LEXICON_JSON,
+    HYPERBOARDS_BOARD: HYPERBOARDS_BOARD_LEXICON_JSON,
+    HYPERBOARDS_DISPLAY_PROFILE: HYPERBOARDS_DISPLAY_PROFILE_LEXICON_JSON,
     ACTIVITY: ACTIVITY_LEXICON_JSON,
-    ATTACHMENT: ATTACHMENT_LEXICON_JSON,
-    COLLECTION: COLLECTION_LEXICON_JSON,
-    CONTRIBUTION_DETAILS: CONTRIBUTION_DETAILS_LEXICON_JSON,
+    CONTRIBUTION: CONTRIBUTION_LEXICON_JSON,
     CONTRIBUTOR_INFORMATION: CONTRIBUTOR_INFORMATION_LEXICON_JSON,
-    EVALUATION: EVALUATION_LEXICON_JSON,
-    MEASUREMENT: MEASUREMENT_LEXICON_JSON,
     RIGHTS: RIGHTS_LEXICON_JSON,
+    HYPERCERTS_COLLECTION: HYPERCERTS_COLLECTION_LEXICON_JSON,
+    CONTEXT_ACKNOWLEDGEMENT: CONTEXT_ACKNOWLEDGEMENT_LEXICON_JSON,
+    CONTEXT_ATTACHMENT: CONTEXT_ATTACHMENT_LEXICON_JSON,
+    CONTEXT_EVALUATION: CONTEXT_EVALUATION_LEXICON_JSON,
+    CONTEXT_MEASUREMENT: CONTEXT_MEASUREMENT_LEXICON_JSON,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_JSON,
     FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_JSON,
-    WORK_SCOPE_TAG: WORK_SCOPE_TAG_LEXICON_JSON,
+    WORKSCOPE_CEL: WORKSCOPE_CEL_LEXICON_JSON,
+    WORKSCOPE_TAG: WORKSCOPE_TAG_LEXICON_JSON,
 };
 // Individual lexicon objects (from lexicons.get())
+const ACTOR_ORGANIZATION_LEXICON_DOC = lexicons.get(ACTOR_ORGANIZATION_NSID);
 const ACTOR_PROFILE_LEXICON_DOC = lexicons.get(ACTOR_PROFILE_NSID);
 const BADGE_AWARD_LEXICON_DOC = lexicons.get(BADGE_AWARD_NSID);
 const BADGE_DEFINITION_LEXICON_DOC = lexicons.get(BADGE_DEFINITION_NSID);
@@ -3105,21 +4202,26 @@ const BADGE_RESPONSE_LEXICON_DOC = lexicons.get(BADGE_RESPONSE_NSID);
 const CERTIFIED_DEFS_LEXICON_DOC = lexicons.get(CERTIFIED_DEFS_NSID);
 const LOCATION_LEXICON_DOC = lexicons.get(LOCATION_NSID);
 const STRONG_REF_LEXICON_DOC = lexicons.get(STRONG_REF_NSID);
+const HYPERBOARDS_BOARD_LEXICON_DOC = lexicons.get(HYPERBOARDS_BOARD_NSID);
+const HYPERBOARDS_DISPLAY_PROFILE_LEXICON_DOC = lexicons.get(HYPERBOARDS_DISPLAY_PROFILE_NSID);
 const ACTIVITY_LEXICON_DOC = lexicons.get(ACTIVITY_NSID);
-const ATTACHMENT_LEXICON_DOC = lexicons.get(ATTACHMENT_NSID);
-const COLLECTION_LEXICON_DOC = lexicons.get(COLLECTION_NSID);
-const CONTRIBUTION_DETAILS_LEXICON_DOC = lexicons.get(CONTRIBUTION_DETAILS_NSID);
+const CONTRIBUTION_LEXICON_DOC = lexicons.get(CONTRIBUTION_NSID);
 const CONTRIBUTOR_INFORMATION_LEXICON_DOC = lexicons.get(CONTRIBUTOR_INFORMATION_NSID);
-const EVALUATION_LEXICON_DOC = lexicons.get(EVALUATION_NSID);
-const MEASUREMENT_LEXICON_DOC = lexicons.get(MEASUREMENT_NSID);
 const RIGHTS_LEXICON_DOC = lexicons.get(RIGHTS_NSID);
+const HYPERCERTS_COLLECTION_LEXICON_DOC = lexicons.get(HYPERCERTS_COLLECTION_NSID);
+const CONTEXT_ACKNOWLEDGEMENT_LEXICON_DOC = lexicons.get(CONTEXT_ACKNOWLEDGEMENT_NSID);
+const CONTEXT_ATTACHMENT_LEXICON_DOC = lexicons.get(CONTEXT_ATTACHMENT_NSID);
+const CONTEXT_EVALUATION_LEXICON_DOC = lexicons.get(CONTEXT_EVALUATION_NSID);
+const CONTEXT_MEASUREMENT_LEXICON_DOC = lexicons.get(CONTEXT_MEASUREMENT_NSID);
 const HYPERCERTS_DEFS_LEXICON_DOC = lexicons.get(HYPERCERTS_DEFS_NSID);
 const FUNDING_RECEIPT_LEXICON_DOC = lexicons.get(FUNDING_RECEIPT_NSID);
-const WORK_SCOPE_TAG_LEXICON_DOC = lexicons.get(WORK_SCOPE_TAG_NSID);
+const WORKSCOPE_CEL_LEXICON_DOC = lexicons.get(WORKSCOPE_CEL_NSID);
+const WORKSCOPE_TAG_LEXICON_DOC = lexicons.get(WORKSCOPE_TAG_NSID);
 /**
  * Lexicon document objects organized by semantic record type.
  */
 const HYPERCERTS_LEXICON_DOC = {
+    ACTOR_ORGANIZATION: ACTOR_ORGANIZATION_LEXICON_DOC,
     ACTOR_PROFILE: ACTOR_PROFILE_LEXICON_DOC,
     BADGE_AWARD: BADGE_AWARD_LEXICON_DOC,
     BADGE_DEFINITION: BADGE_DEFINITION_LEXICON_DOC,
@@ -3127,28 +4229,33 @@ const HYPERCERTS_LEXICON_DOC = {
     CERTIFIED_DEFS: CERTIFIED_DEFS_LEXICON_DOC,
     LOCATION: LOCATION_LEXICON_DOC,
     STRONG_REF: STRONG_REF_LEXICON_DOC,
+    HYPERBOARDS_BOARD: HYPERBOARDS_BOARD_LEXICON_DOC,
+    HYPERBOARDS_DISPLAY_PROFILE: HYPERBOARDS_DISPLAY_PROFILE_LEXICON_DOC,
     ACTIVITY: ACTIVITY_LEXICON_DOC,
-    ATTACHMENT: ATTACHMENT_LEXICON_DOC,
-    COLLECTION: COLLECTION_LEXICON_DOC,
-    CONTRIBUTION_DETAILS: CONTRIBUTION_DETAILS_LEXICON_DOC,
+    CONTRIBUTION: CONTRIBUTION_LEXICON_DOC,
     CONTRIBUTOR_INFORMATION: CONTRIBUTOR_INFORMATION_LEXICON_DOC,
-    EVALUATION: EVALUATION_LEXICON_DOC,
-    MEASUREMENT: MEASUREMENT_LEXICON_DOC,
     RIGHTS: RIGHTS_LEXICON_DOC,
+    HYPERCERTS_COLLECTION: HYPERCERTS_COLLECTION_LEXICON_DOC,
+    CONTEXT_ACKNOWLEDGEMENT: CONTEXT_ACKNOWLEDGEMENT_LEXICON_DOC,
+    CONTEXT_ATTACHMENT: CONTEXT_ATTACHMENT_LEXICON_DOC,
+    CONTEXT_EVALUATION: CONTEXT_EVALUATION_LEXICON_DOC,
+    CONTEXT_MEASUREMENT: CONTEXT_MEASUREMENT_LEXICON_DOC,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_DOC,
     FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_DOC,
-    WORK_SCOPE_TAG: WORK_SCOPE_TAG_LEXICON_DOC,
+    WORKSCOPE_CEL: WORKSCOPE_CEL_LEXICON_DOC,
+    WORKSCOPE_TAG: WORKSCOPE_TAG_LEXICON_DOC,
 };
 
 exports.ACTIVITY_LEXICON_DOC = ACTIVITY_LEXICON_DOC;
 exports.ACTIVITY_LEXICON_JSON = ACTIVITY_LEXICON_JSON;
 exports.ACTIVITY_NSID = ACTIVITY_NSID;
+exports.ACTOR_ORGANIZATION_LEXICON_DOC = ACTOR_ORGANIZATION_LEXICON_DOC;
+exports.ACTOR_ORGANIZATION_LEXICON_JSON = ACTOR_ORGANIZATION_LEXICON_JSON;
+exports.ACTOR_ORGANIZATION_NSID = ACTOR_ORGANIZATION_NSID;
 exports.ACTOR_PROFILE_LEXICON_DOC = ACTOR_PROFILE_LEXICON_DOC;
 exports.ACTOR_PROFILE_LEXICON_JSON = ACTOR_PROFILE_LEXICON_JSON;
 exports.ACTOR_PROFILE_NSID = ACTOR_PROFILE_NSID;
-exports.ATTACHMENT_LEXICON_DOC = ATTACHMENT_LEXICON_DOC;
-exports.ATTACHMENT_LEXICON_JSON = ATTACHMENT_LEXICON_JSON;
-exports.ATTACHMENT_NSID = ATTACHMENT_NSID;
+exports.AppCertifiedActorOrganization = organization;
 exports.AppCertifiedActorProfile = profile;
 exports.AppCertifiedBadgeAward = award;
 exports.AppCertifiedBadgeDefinition = definition;
@@ -3167,22 +4274,37 @@ exports.BADGE_RESPONSE_NSID = BADGE_RESPONSE_NSID;
 exports.CERTIFIED_DEFS_LEXICON_DOC = CERTIFIED_DEFS_LEXICON_DOC;
 exports.CERTIFIED_DEFS_LEXICON_JSON = CERTIFIED_DEFS_LEXICON_JSON;
 exports.CERTIFIED_DEFS_NSID = CERTIFIED_DEFS_NSID;
-exports.COLLECTION_LEXICON_DOC = COLLECTION_LEXICON_DOC;
-exports.COLLECTION_LEXICON_JSON = COLLECTION_LEXICON_JSON;
-exports.COLLECTION_NSID = COLLECTION_NSID;
-exports.CONTRIBUTION_DETAILS_LEXICON_DOC = CONTRIBUTION_DETAILS_LEXICON_DOC;
-exports.CONTRIBUTION_DETAILS_LEXICON_JSON = CONTRIBUTION_DETAILS_LEXICON_JSON;
-exports.CONTRIBUTION_DETAILS_NSID = CONTRIBUTION_DETAILS_NSID;
+exports.CONTEXT_ACKNOWLEDGEMENT_LEXICON_DOC = CONTEXT_ACKNOWLEDGEMENT_LEXICON_DOC;
+exports.CONTEXT_ACKNOWLEDGEMENT_LEXICON_JSON = CONTEXT_ACKNOWLEDGEMENT_LEXICON_JSON;
+exports.CONTEXT_ACKNOWLEDGEMENT_NSID = CONTEXT_ACKNOWLEDGEMENT_NSID;
+exports.CONTEXT_ATTACHMENT_LEXICON_DOC = CONTEXT_ATTACHMENT_LEXICON_DOC;
+exports.CONTEXT_ATTACHMENT_LEXICON_JSON = CONTEXT_ATTACHMENT_LEXICON_JSON;
+exports.CONTEXT_ATTACHMENT_NSID = CONTEXT_ATTACHMENT_NSID;
+exports.CONTEXT_EVALUATION_LEXICON_DOC = CONTEXT_EVALUATION_LEXICON_DOC;
+exports.CONTEXT_EVALUATION_LEXICON_JSON = CONTEXT_EVALUATION_LEXICON_JSON;
+exports.CONTEXT_EVALUATION_NSID = CONTEXT_EVALUATION_NSID;
+exports.CONTEXT_MEASUREMENT_LEXICON_DOC = CONTEXT_MEASUREMENT_LEXICON_DOC;
+exports.CONTEXT_MEASUREMENT_LEXICON_JSON = CONTEXT_MEASUREMENT_LEXICON_JSON;
+exports.CONTEXT_MEASUREMENT_NSID = CONTEXT_MEASUREMENT_NSID;
+exports.CONTRIBUTION_LEXICON_DOC = CONTRIBUTION_LEXICON_DOC;
+exports.CONTRIBUTION_LEXICON_JSON = CONTRIBUTION_LEXICON_JSON;
+exports.CONTRIBUTION_NSID = CONTRIBUTION_NSID;
 exports.CONTRIBUTOR_INFORMATION_LEXICON_DOC = CONTRIBUTOR_INFORMATION_LEXICON_DOC;
 exports.CONTRIBUTOR_INFORMATION_LEXICON_JSON = CONTRIBUTOR_INFORMATION_LEXICON_JSON;
 exports.CONTRIBUTOR_INFORMATION_NSID = CONTRIBUTOR_INFORMATION_NSID;
 exports.ComAtprotoRepoStrongRef = strongRef;
-exports.EVALUATION_LEXICON_DOC = EVALUATION_LEXICON_DOC;
-exports.EVALUATION_LEXICON_JSON = EVALUATION_LEXICON_JSON;
-exports.EVALUATION_NSID = EVALUATION_NSID;
 exports.FUNDING_RECEIPT_LEXICON_DOC = FUNDING_RECEIPT_LEXICON_DOC;
 exports.FUNDING_RECEIPT_LEXICON_JSON = FUNDING_RECEIPT_LEXICON_JSON;
 exports.FUNDING_RECEIPT_NSID = FUNDING_RECEIPT_NSID;
+exports.HYPERBOARDS_BOARD_LEXICON_DOC = HYPERBOARDS_BOARD_LEXICON_DOC;
+exports.HYPERBOARDS_BOARD_LEXICON_JSON = HYPERBOARDS_BOARD_LEXICON_JSON;
+exports.HYPERBOARDS_BOARD_NSID = HYPERBOARDS_BOARD_NSID;
+exports.HYPERBOARDS_DISPLAY_PROFILE_LEXICON_DOC = HYPERBOARDS_DISPLAY_PROFILE_LEXICON_DOC;
+exports.HYPERBOARDS_DISPLAY_PROFILE_LEXICON_JSON = HYPERBOARDS_DISPLAY_PROFILE_LEXICON_JSON;
+exports.HYPERBOARDS_DISPLAY_PROFILE_NSID = HYPERBOARDS_DISPLAY_PROFILE_NSID;
+exports.HYPERCERTS_COLLECTION_LEXICON_DOC = HYPERCERTS_COLLECTION_LEXICON_DOC;
+exports.HYPERCERTS_COLLECTION_LEXICON_JSON = HYPERCERTS_COLLECTION_LEXICON_JSON;
+exports.HYPERCERTS_COLLECTION_NSID = HYPERCERTS_COLLECTION_NSID;
 exports.HYPERCERTS_DEFS_LEXICON_DOC = HYPERCERTS_DEFS_LEXICON_DOC;
 exports.HYPERCERTS_DEFS_LEXICON_JSON = HYPERCERTS_DEFS_LEXICON_JSON;
 exports.HYPERCERTS_DEFS_NSID = HYPERCERTS_DEFS_NSID;
@@ -3195,32 +4317,36 @@ exports.HYPERCERTS_SCHEMA_DICT = schemaDict;
 exports.LOCATION_LEXICON_DOC = LOCATION_LEXICON_DOC;
 exports.LOCATION_LEXICON_JSON = LOCATION_LEXICON_JSON;
 exports.LOCATION_NSID = LOCATION_NSID;
-exports.MEASUREMENT_LEXICON_DOC = MEASUREMENT_LEXICON_DOC;
-exports.MEASUREMENT_LEXICON_JSON = MEASUREMENT_LEXICON_JSON;
-exports.MEASUREMENT_NSID = MEASUREMENT_NSID;
+exports.OrgHyperboardsBoard = board;
+exports.OrgHyperboardsDisplayProfile = displayProfile;
 exports.OrgHypercertsClaimActivity = activity;
-exports.OrgHypercertsClaimAttachment = attachment;
-exports.OrgHypercertsClaimCollection = collection;
-exports.OrgHypercertsClaimContributionDetails = contributionDetails;
+exports.OrgHypercertsClaimContribution = contribution;
 exports.OrgHypercertsClaimContributorInformation = contributorInformation;
-exports.OrgHypercertsClaimEvaluation = evaluation;
-exports.OrgHypercertsClaimMeasurement = measurement;
 exports.OrgHypercertsClaimRights = rights;
+exports.OrgHypercertsCollection = collection;
+exports.OrgHypercertsContextAcknowledgement = acknowledgement;
+exports.OrgHypercertsContextAttachment = attachment;
+exports.OrgHypercertsContextEvaluation = evaluation;
+exports.OrgHypercertsContextMeasurement = measurement;
 exports.OrgHypercertsDefs = defs;
 exports.OrgHypercertsFundingReceipt = receipt;
-exports.OrgHypercertsHelperWorkScopeTag = workScopeTag;
+exports.OrgHypercertsWorkscopeCel = cel;
+exports.OrgHypercertsWorkscopeTag = tag;
 exports.RIGHTS_LEXICON_DOC = RIGHTS_LEXICON_DOC;
 exports.RIGHTS_LEXICON_JSON = RIGHTS_LEXICON_JSON;
 exports.RIGHTS_NSID = RIGHTS_NSID;
 exports.STRONG_REF_LEXICON_DOC = STRONG_REF_LEXICON_DOC;
 exports.STRONG_REF_LEXICON_JSON = STRONG_REF_LEXICON_JSON;
 exports.STRONG_REF_NSID = STRONG_REF_NSID;
-exports.WORK_SCOPE_TAG_LEXICON_DOC = WORK_SCOPE_TAG_LEXICON_DOC;
-exports.WORK_SCOPE_TAG_LEXICON_JSON = WORK_SCOPE_TAG_LEXICON_JSON;
-exports.WORK_SCOPE_TAG_NSID = WORK_SCOPE_TAG_NSID;
+exports.WORKSCOPE_CEL_LEXICON_DOC = WORKSCOPE_CEL_LEXICON_DOC;
+exports.WORKSCOPE_CEL_LEXICON_JSON = WORKSCOPE_CEL_LEXICON_JSON;
+exports.WORKSCOPE_CEL_NSID = WORKSCOPE_CEL_NSID;
+exports.WORKSCOPE_TAG_LEXICON_DOC = WORKSCOPE_TAG_LEXICON_DOC;
+exports.WORKSCOPE_TAG_LEXICON_JSON = WORKSCOPE_TAG_LEXICON_JSON;
+exports.WORKSCOPE_TAG_NSID = WORKSCOPE_TAG_NSID;
 exports.asPredicate = asPredicate;
-exports.is$typed = is$typed$i;
+exports.is$typed = is$typed$n;
 exports.lexicons = lexicons;
 exports.maybe$typed = maybe$typed;
-exports.validate = validate$i;
+exports.validate = validate$n;
 //# sourceMappingURL=index.cjs.map