@hypercerts-org/lexicon 0.10.0-beta.6 → 0.10.0-beta.8

package/dist/index.mjs

@@ -16,7 +16,7 @@ function is$type($type, id, hash) {
                 $type.startsWith(id) &&
                 $type.endsWith(hash);
 }
-function is$typed$f(v, id, hash) {
+function is$typed$g(v, id, hash) {
     return isObject(v) && '$type' in v && is$type(v.$type, id, hash);
 }
 function maybe$typed(v, id, hash) {
@@ -282,16 +282,32 @@ const schemaDict = {
                         },
                         shortDescription: {
                             type: 'string',
-                            description: 'Short blurb of the impact work done.',
+                            description: 'Short summary of this activity claim, suitable for previews and list views. Rich text annotations may be provided via `shortDescriptionFacets`.',
                             maxLength: 3000,
                             maxGraphemes: 300,
                         },
+                        shortDescriptionFacets: {
+                            type: 'array',
+                            description: 'Rich text annotations for `shortDescription` (mentions, URLs, hashtags, etc).',
+                            items: {
+                                type: 'ref',
+                                ref: 'lex:app.bsky.richtext.facet',
+                            },
+                        },
                         description: {
                             type: 'string',
-                            description: 'Optional longer description of the impact work done.',
+                            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',
+                            },
+                        },
                         image: {
                             type: 'union',
                             refs: [
@@ -301,9 +317,14 @@ const schemaDict = {
                             description: 'The hypercert visual representation as a URI or image blob.',
                         },
                         workScope: {
-                            type: 'ref',
-                            ref: 'lex:com.atproto.repo.strongRef',
-                            description: 'A strong reference to a record defining the scope of work. The record referenced should describe the logical scope using label-based conditions.',
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#workScopeAll',
+                                'lex:org.hypercerts.defs#workScopeAny',
+                                'lex:org.hypercerts.defs#workScopeNot',
+                                'lex:org.hypercerts.defs#workScopeAtom',
+                            ],
+                            description: 'Work scope logic expression using boolean operators (all/any/not) and atomic scope references.',
                         },
                         startDate: {
                             type: 'string',
@@ -346,17 +367,17 @@ const schemaDict = {
             },
             contributor: {
                 type: 'object',
-                required: ['contributorInformation'],
+                required: ['contributorIdentity'],
                 properties: {
-                    contributorInformation: {
+                    contributorIdentity: {
                         type: 'union',
                         refs: [
                             'lex:org.hypercerts.claim.activity#contributorIdentity',
                             'lex:com.atproto.repo.strongRef',
                         ],
-                        description: 'Contributor information as a string (DID or identifier) or strong reference to for instance org.hypercerts.claim.contributorInformation#main.',
+                        description: 'Contributor identity as a string (DID or identifier) via org.hypercerts.claim.activity#contributorIdentity, or a strong reference to a contributor information record.',
                     },
-                    weight: {
+                    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.',
                     },
@@ -366,7 +387,7 @@ const schemaDict = {
                             'lex:org.hypercerts.claim.activity#contributorRole',
                             'lex:com.atproto.repo.strongRef',
                         ],
-                        description: 'Contribution details as a string or strong reference to org.hypercerts.claim.contributionDetails#main.',
+                        description: 'Contribution details as a string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record.',
                     },
                 },
             },
@@ -380,21 +401,6 @@ const schemaDict = {
                 maxLength: 10000,
                 maxGraphemes: 1000,
             },
-            activityWeight: {
-                type: 'object',
-                required: ['activity', 'weight'],
-                properties: {
-                    activity: {
-                        type: 'ref',
-                        ref: 'lex:com.atproto.repo.strongRef',
-                        description: 'A strong reference to a hypercert activity record. This activity must conform to the lexicon org.hypercerts.claim.activity',
-                    },
-                    weight: {
-                        type: 'string',
-                        description: 'The relative weight/importance of this hypercert activity (stored as a string to avoid float precision issues). Weights can be any positive numeric values and do not need to sum to a specific total; normalization can be performed by the consuming application as needed.',
-                    },
-                },
-            },
         },
     },
     OrgHypercertsClaimCollection: {
@@ -430,12 +436,28 @@ const schemaDict = {
                             ref: 'lex:pub.leaflet.pages.linearDocument#main',
                             description: 'Rich-text description, represented as a Leaflet linear document.',
                         },
+                        avatar: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#smallImage',
+                            ],
+                            description: "The collection's avatar/profile image as a URI or image blob.",
+                        },
+                        banner: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#uri',
+                                'lex:org.hypercerts.defs#largeImage',
+                            ],
+                            description: 'Larger horizontal image to display behind the collection view.',
+                        },
                         items: {
                             type: 'array',
-                            description: 'Array of strong references to items in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.claim.collection).',
+                            description: 'Array of items in this collection with optional weights.',
                             items: {
                                 type: 'ref',
-                                ref: 'lex:com.atproto.repo.strongRef',
+                                ref: 'lex:org.hypercerts.claim.collection#item',
                             },
                         },
                         createdAt: {
@@ -446,6 +468,21 @@ const schemaDict = {
                     },
                 },
             },
+            item: {
+                type: 'object',
+                required: ['itemIdentifier'],
+                properties: {
+                    itemIdentifier: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                        description: 'Strong reference to an item in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.claim.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.',
+                    },
+                },
+            },
         },
     },
     OrgHypercertsClaimContributionDetails: {
@@ -867,6 +904,94 @@ const schemaDict = {
                     },
                 },
             },
+            workScopeAll: {
+                type: 'object',
+                required: ['op', 'args'],
+                description: 'Logical AND operation: all arguments must be satisfied.',
+                properties: {
+                    op: {
+                        type: 'string',
+                        const: 'all',
+                        description: "Operator type: 'all' (logical AND)",
+                    },
+                    args: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#workScopeAll',
+                                'lex:org.hypercerts.defs#workScopeAny',
+                                'lex:org.hypercerts.defs#workScopeNot',
+                                'lex:org.hypercerts.defs#workScopeAtom',
+                            ],
+                        },
+                        minLength: 1,
+                        maxLength: 100,
+                        description: 'Array of work scope expressions that must all be satisfied',
+                    },
+                },
+            },
+            workScopeAny: {
+                type: 'object',
+                required: ['op', 'args'],
+                description: 'Logical OR operation: at least one argument must be satisfied.',
+                properties: {
+                    op: {
+                        type: 'string',
+                        const: 'any',
+                        description: "Operator type: 'any' (logical OR)",
+                    },
+                    args: {
+                        type: 'array',
+                        items: {
+                            type: 'union',
+                            refs: [
+                                'lex:org.hypercerts.defs#workScopeAll',
+                                'lex:org.hypercerts.defs#workScopeAny',
+                                'lex:org.hypercerts.defs#workScopeNot',
+                                'lex:org.hypercerts.defs#workScopeAtom',
+                            ],
+                        },
+                        minLength: 1,
+                        maxLength: 100,
+                        description: 'Array of work scope expressions, at least one of which must be satisfied',
+                    },
+                },
+            },
+            workScopeNot: {
+                type: 'object',
+                required: ['op', 'arg'],
+                description: 'Logical NOT operation: the argument must not be satisfied.',
+                properties: {
+                    op: {
+                        type: 'string',
+                        const: 'not',
+                        description: "Operator type: 'not' (logical NOT)",
+                    },
+                    arg: {
+                        type: 'union',
+                        refs: [
+                            'lex:org.hypercerts.defs#workScopeAll',
+                            'lex:org.hypercerts.defs#workScopeAny',
+                            'lex:org.hypercerts.defs#workScopeNot',
+                            'lex:org.hypercerts.defs#workScopeAtom',
+                        ],
+                        description: 'Work scope expression that must not be satisfied',
+                    },
+                },
+            },
+            workScopeAtom: {
+                type: 'object',
+                required: ['atom'],
+                description: 'Atomic scope reference: a strong reference to a scope record.',
+                properties: {
+                    atom: {
+                        type: 'ref',
+                        ref: 'lex:com.atproto.repo.strongRef',
+                        description: 'Strong reference to an org.hypercerts.helper.workScopeTag record',
+                    },
+                },
+            },
         },
     },
     OrgHypercertsFundingReceipt: {
@@ -935,11 +1060,76 @@ const schemaDict = {
             },
         },
     },
+    OrgHypercertsHelperWorkScopeTag: {
+        lexicon: 1,
+        id: 'org.hypercerts.helper.workScopeTag',
+        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.',
+                key: 'tid',
+                record: {
+                    type: 'object',
+                    required: ['createdAt', 'key', 'label'],
+                    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').",
+                            maxLength: 120,
+                        },
+                        label: {
+                            type: 'string',
+                            description: 'Human-readable label for this scope.',
+                            maxLength: 200,
+                        },
+                        kind: {
+                            type: 'string',
+                            description: 'Category type of this scope. Recommended values: topic, language, domain, method, tag.',
+                            maxLength: 50,
+                        },
+                        description: {
+                            type: 'string',
+                            description: 'Optional longer description of this scope.',
+                            maxLength: 10000,
+                            maxGraphemes: 1000,
+                        },
+                        parent: {
+                            type: 'ref',
+                            ref: 'lex:com.atproto.repo.strongRef',
+                            description: 'Optional strong reference to a parent scope record for taxonomy/hierarchy support.',
+                        },
+                        aliases: {
+                            type: 'array',
+                            items: {
+                                type: 'string',
+                                maxLength: 200,
+                            },
+                            maxLength: 50,
+                            description: 'Optional array of alternative names or identifiers for this scope.',
+                        },
+                        externalReference: {
+                            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.',
+                        },
+                    },
+                },
+            },
+        },
+    },
 };
 const schemas = Object.values(schemaDict);
 const lexicons = new Lexicons(schemas);
-function validate$f(v, id, hash, requiredType) {
-    return (requiredType ? is$typed$f : maybe$typed)(v, id, hash)
+function validate$g(v, id, hash, requiredType) {
+    return (requiredType ? is$typed$g : maybe$typed)(v, id, hash)
         ? lexicons.validate(`${id}#${hash}`, v)
         : {
             success: false,
@@ -963,11 +1153,12 @@ const ids = {
     OrgHypercertsClaimRights: 'org.hypercerts.claim.rights',
     OrgHypercertsDefs: 'org.hypercerts.defs',
     OrgHypercertsFundingReceipt: 'org.hypercerts.funding.receipt',
+    OrgHypercertsHelperWorkScopeTag: 'org.hypercerts.helper.workScopeTag',
 };
 
-var lexicon$f = 1;
-var id$u = "app.certified.badge.award";
-var defs$h = {
+var lexicon$g = 1;
+var id$w = "app.certified.badge.award";
+var defs$i = {
 	main: {
 		type: "record",
 		description: "Records a badge award to a user, project, or activity claim.",
@@ -1007,14 +1198,14 @@ var defs$h = {
 	}
 };
 var BADGE_AWARD_LEXICON_JSON = {
-	lexicon: lexicon$f,
-	id: id$u,
-	defs: defs$h
+	lexicon: lexicon$g,
+	id: id$w,
+	defs: defs$i
 };
 
-var lexicon$e = 1;
-var id$t = "app.certified.badge.definition";
-var defs$g = {
+var lexicon$f = 1;
+var id$v = "app.certified.badge.definition";
+var defs$h = {
 	main: {
 		type: "record",
 		description: "Defines a badge that can be awarded via badge award records to users, projects, or activity claims.",
@@ -1069,14 +1260,14 @@ var defs$g = {
 	}
 };
 var BADGE_DEFINITION_LEXICON_JSON = {
-	lexicon: lexicon$e,
-	id: id$t,
-	defs: defs$g
+	lexicon: lexicon$f,
+	id: id$v,
+	defs: defs$h
 };
 
-var lexicon$d = 1;
-var id$s = "app.certified.badge.response";
-var defs$f = {
+var lexicon$e = 1;
+var id$u = "app.certified.badge.response";
+var defs$g = {
 	main: {
 		type: "record",
 		description: "Recipient response to a badge award.",
@@ -1116,15 +1307,15 @@ var defs$f = {
 	}
 };
 var BADGE_RESPONSE_LEXICON_JSON = {
-	lexicon: lexicon$d,
-	id: id$s,
-	defs: defs$f
+	lexicon: lexicon$e,
+	id: id$u,
+	defs: defs$g
 };
 
-var lexicon$c = 1;
-var id$r = "app.certified.defs";
+var lexicon$d = 1;
+var id$t = "app.certified.defs";
 var description$1 = "Common type definitions used across certified protocols.";
-var defs$e = {
+var defs$f = {
 	did: {
 		type: "string",
 		format: "did",
@@ -1132,15 +1323,15 @@ var defs$e = {
 	}
 };
 var CERTIFIED_DEFS_LEXICON_JSON = {
-	lexicon: lexicon$c,
-	id: id$r,
+	lexicon: lexicon$d,
+	id: id$t,
 	description: description$1,
-	defs: defs$e
+	defs: defs$f
 };
 
-var lexicon$b = 1;
-var id$q = "app.certified.location";
-var defs$d = {
+var lexicon$c = 1;
+var id$s = "app.certified.location";
+var defs$e = {
 	main: {
 		type: "record",
 		description: "A location reference",
@@ -1205,15 +1396,15 @@ var defs$d = {
 	}
 };
 var LOCATION_LEXICON_JSON = {
-	lexicon: lexicon$b,
-	id: id$q,
-	defs: defs$d
+	lexicon: lexicon$c,
+	id: id$s,
+	defs: defs$e
 };
 
-var lexicon$a = 1;
-var id$p = "com.atproto.repo.strongRef";
+var lexicon$b = 1;
+var id$r = "com.atproto.repo.strongRef";
 var description = "A URI with a content-hash fingerprint.";
-var defs$c = {
+var defs$d = {
 	main: {
 		type: "object",
 		required: [
@@ -1233,15 +1424,15 @@ var defs$c = {
 	}
 };
 var STRONGREF_LEXICON_JSON = {
-	lexicon: lexicon$a,
-	id: id$p,
+	lexicon: lexicon$b,
+	id: id$r,
 	description: description,
-	defs: defs$c
+	defs: defs$d
 };
 
-var lexicon$9 = 1;
-var id$o = "org.hypercerts.claim.activity";
-var defs$b = {
+var lexicon$a = 1;
+var id$q = "org.hypercerts.claim.activity";
+var defs$c = {
 	main: {
 		type: "record",
 		description: "A hypercert record tracking impact work.",
@@ -1261,16 +1452,32 @@ var defs$b = {
 				},
 				shortDescription: {
 					type: "string",
-					description: "Short blurb of the impact work done.",
+					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: "string",
-					description: "Optional longer description of the impact work done.",
+					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: [
@@ -1280,9 +1487,14 @@ var defs$b = {
 					description: "The hypercert visual representation as a URI or image blob."
 				},
 				workScope: {
-					type: "ref",
-					ref: "com.atproto.repo.strongRef",
-					description: "A strong reference to a record defining the scope of work. The record referenced should describe the logical scope using label-based conditions."
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#workScopeAll",
+						"org.hypercerts.defs#workScopeAny",
+						"org.hypercerts.defs#workScopeNot",
+						"org.hypercerts.defs#workScopeAtom"
+					],
+					description: "Work scope logic expression using boolean operators (all/any/not) and atomic scope references."
 				},
 				startDate: {
 					type: "string",
@@ -1326,18 +1538,18 @@ var defs$b = {
 	contributor: {
 		type: "object",
 		required: [
-			"contributorInformation"
+			"contributorIdentity"
 		],
 		properties: {
-			contributorInformation: {
+			contributorIdentity: {
 				type: "union",
 				refs: [
 					"#contributorIdentity",
 					"com.atproto.repo.strongRef"
 				],
-				description: "Contributor information as a string (DID or identifier) or strong reference to for instance org.hypercerts.claim.contributorInformation#main."
+				description: "Contributor identity as a string (DID or identifier) via org.hypercerts.claim.activity#contributorIdentity, or a strong reference to a contributor information record."
 			},
-			weight: {
+			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."
 			},
@@ -1347,7 +1559,7 @@ var defs$b = {
 					"#contributorRole",
 					"com.atproto.repo.strongRef"
 				],
-				description: "Contribution details as a string or strong reference to org.hypercerts.claim.contributionDetails#main."
+				description: "Contribution details as a string via org.hypercerts.claim.activity#contributorRole, or a strong reference to a contribution details record."
 			}
 		}
 	},
@@ -1360,35 +1572,17 @@ var defs$b = {
 		description: "Contribution details as a string.",
 		maxLength: 10000,
 		maxGraphemes: 1000
-	},
-	activityWeight: {
-		type: "object",
-		required: [
-			"activity",
-			"weight"
-		],
-		properties: {
-			activity: {
-				type: "ref",
-				ref: "com.atproto.repo.strongRef",
-				description: "A strong reference to a hypercert activity record. This activity must conform to the lexicon org.hypercerts.claim.activity"
-			},
-			weight: {
-				type: "string",
-				description: "The relative weight/importance of this hypercert activity (stored as a string to avoid float precision issues). Weights can be any positive numeric values and do not need to sum to a specific total; normalization can be performed by the consuming application as needed."
-			}
-		}
 	}
 };
 var ACTIVITY_LEXICON_JSON = {
-	lexicon: lexicon$9,
-	id: id$o,
-	defs: defs$b
+	lexicon: lexicon$a,
+	id: id$q,
+	defs: defs$c
 };
 
-var lexicon$8 = 1;
-var id$n = "org.hypercerts.claim.collection";
-var defs$a = {
+var lexicon$9 = 1;
+var id$p = "org.hypercerts.claim.collection";
+var defs$b = {
 	main: {
 		type: "record",
 		description: "A collection/group of items (activities and/or other collections). Collections support recursive nesting. Use app.certified.location as a sidecar (same TID) for location metadata.",
@@ -1422,12 +1616,28 @@ var defs$a = {
 					ref: "pub.leaflet.pages.linearDocument#main",
 					description: "Rich-text description, represented as a Leaflet linear document."
 				},
+				avatar: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallImage"
+					],
+					description: "The collection's avatar/profile image as a URI or image blob."
+				},
+				banner: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#largeImage"
+					],
+					description: "Larger horizontal image to display behind the collection view."
+				},
 				items: {
 					type: "array",
-					description: "Array of strong references to items in this collection. Items can be activities (org.hypercerts.claim.activity) and/or other collections (org.hypercerts.claim.collection).",
+					description: "Array of items in this collection with optional weights.",
 					items: {
 						type: "ref",
-						ref: "com.atproto.repo.strongRef"
+						ref: "#item"
 					}
 				},
 				createdAt: {
@@ -1437,17 +1647,34 @@ var defs$a = {
 				}
 			}
 		}
+	},
+	item: {
+		type: "object",
+		required: [
+			"itemIdentifier"
+		],
+		properties: {
+			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)."
+			},
+			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."
+			}
+		}
 	}
 };
 var COLLECTION_LEXICON_JSON = {
-	lexicon: lexicon$8,
-	id: id$n,
-	defs: defs$a
+	lexicon: lexicon$9,
+	id: id$p,
+	defs: defs$b
 };
 
-var lexicon$7 = 1;
-var id$m = "org.hypercerts.claim.contributionDetails";
-var defs$9 = {
+var lexicon$8 = 1;
+var id$o = "org.hypercerts.claim.contributionDetails";
+var defs$a = {
 	main: {
 		type: "record",
 		description: "Details about a specific contribution including role, description, and timeframe.",
@@ -1489,14 +1716,14 @@ var defs$9 = {
 	}
 };
 var CONTRIBUTIONDETAILS_LEXICON_JSON = {
-	lexicon: lexicon$7,
-	id: id$m,
-	defs: defs$9
+	lexicon: lexicon$8,
+	id: id$o,
+	defs: defs$a
 };
 
-var lexicon$6 = 1;
-var id$l = "org.hypercerts.claim.contributorInformation";
-var defs$8 = {
+var lexicon$7 = 1;
+var id$n = "org.hypercerts.claim.contributorInformation";
+var defs$9 = {
 	main: {
 		type: "record",
 		description: "Contributor information including identifier, display name, and image.",
@@ -1534,14 +1761,14 @@ var defs$8 = {
 	}
 };
 var CONTRIBUTORINFORMATION_LEXICON_JSON = {
-	lexicon: lexicon$6,
-	id: id$l,
-	defs: defs$8
+	lexicon: lexicon$7,
+	id: id$n,
+	defs: defs$9
 };
 
-var lexicon$5 = 1;
-var id$k = "org.hypercerts.claim.evaluation";
-var defs$7 = {
+var lexicon$6 = 1;
+var id$m = "org.hypercerts.claim.evaluation";
+var defs$8 = {
 	score: {
 		type: "object",
 		description: "Overall score for an evaluation on a numeric scale.",
@@ -1638,14 +1865,14 @@ var defs$7 = {
 	}
 };
 var EVALUATION_LEXICON_JSON = {
-	lexicon: lexicon$5,
-	id: id$k,
-	defs: defs$7
+	lexicon: lexicon$6,
+	id: id$m,
+	defs: defs$8
 };
 
-var lexicon$4 = 1;
-var id$j = "org.hypercerts.claim.evidence";
-var defs$6 = {
+var lexicon$5 = 1;
+var id$l = "org.hypercerts.claim.evidence";
+var defs$7 = {
 	main: {
 		type: "record",
 		description: "A piece of evidence related to a hypercert record (e.g. an activity, project, claim, or evaluation). Evidence may support, clarify, or challenge the referenced subject.",
@@ -1707,14 +1934,14 @@ var defs$6 = {
 	}
 };
 var EVIDENCE_LEXICON_JSON = {
-	lexicon: lexicon$4,
-	id: id$j,
-	defs: defs$6
+	lexicon: lexicon$5,
+	id: id$l,
+	defs: defs$7
 };
 
-var lexicon$3 = 1;
-var id$i = "org.hypercerts.claim.measurement";
-var defs$5 = {
+var lexicon$4 = 1;
+var id$k = "org.hypercerts.claim.measurement";
+var defs$6 = {
 	main: {
 		type: "record",
 		description: "Measurement data related to a hypercert record (e.g. an activity and its impact).",
@@ -1786,14 +2013,14 @@ var defs$5 = {
 	}
 };
 var MEASUREMENT_LEXICON_JSON = {
-	lexicon: lexicon$3,
-	id: id$i,
-	defs: defs$5
+	lexicon: lexicon$4,
+	id: id$k,
+	defs: defs$6
 };
 
-var lexicon$2 = 1;
-var id$h = "org.hypercerts.claim.rights";
-var defs$4 = {
+var lexicon$3 = 1;
+var id$j = "org.hypercerts.claim.rights";
+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.",
@@ -1839,14 +2066,14 @@ var defs$4 = {
 	}
 };
 var RIGHTS_LEXICON_JSON = {
-	lexicon: lexicon$2,
-	id: id$h,
-	defs: defs$4
+	lexicon: lexicon$3,
+	id: id$j,
+	defs: defs$5
 };
 
-var lexicon$1 = 1;
-var id$g = "org.hypercerts.defs";
-var defs$3 = {
+var lexicon$2 = 1;
+var id$i = "org.hypercerts.defs";
+var defs$4 = {
 	uri: {
 		type: "object",
 		required: [
@@ -1935,17 +2162,116 @@ var defs$3 = {
 				description: "Image (up to 10MB)"
 			}
 		}
+	},
+	workScopeAll: {
+		type: "object",
+		required: [
+			"op",
+			"args"
+		],
+		description: "Logical AND operation: all arguments must be satisfied.",
+		properties: {
+			op: {
+				type: "string",
+				"const": "all",
+				description: "Operator type: 'all' (logical AND)"
+			},
+			args: {
+				type: "array",
+				items: {
+					type: "union",
+					refs: [
+						"#workScopeAll",
+						"#workScopeAny",
+						"#workScopeNot",
+						"#workScopeAtom"
+					]
+				},
+				minLength: 1,
+				maxLength: 100,
+				description: "Array of work scope expressions that must all be satisfied"
+			}
+		}
+	},
+	workScopeAny: {
+		type: "object",
+		required: [
+			"op",
+			"args"
+		],
+		description: "Logical OR operation: at least one argument must be satisfied.",
+		properties: {
+			op: {
+				type: "string",
+				"const": "any",
+				description: "Operator type: 'any' (logical OR)"
+			},
+			args: {
+				type: "array",
+				items: {
+					type: "union",
+					refs: [
+						"#workScopeAll",
+						"#workScopeAny",
+						"#workScopeNot",
+						"#workScopeAtom"
+					]
+				},
+				minLength: 1,
+				maxLength: 100,
+				description: "Array of work scope expressions, at least one of which must be satisfied"
+			}
+		}
+	},
+	workScopeNot: {
+		type: "object",
+		required: [
+			"op",
+			"arg"
+		],
+		description: "Logical NOT operation: the argument must not be satisfied.",
+		properties: {
+			op: {
+				type: "string",
+				"const": "not",
+				description: "Operator type: 'not' (logical NOT)"
+			},
+			arg: {
+				type: "union",
+				refs: [
+					"#workScopeAll",
+					"#workScopeAny",
+					"#workScopeNot",
+					"#workScopeAtom"
+				],
+				description: "Work scope expression that must not be satisfied"
+			}
+		}
+	},
+	workScopeAtom: {
+		type: "object",
+		required: [
+			"atom"
+		],
+		description: "Atomic scope reference: a strong reference to a scope record.",
+		properties: {
+			atom: {
+				type: "ref",
+				ref: "com.atproto.repo.strongRef",
+				description: "Strong reference to an org.hypercerts.helper.workScopeTag record"
+			}
+		}
 	}
 };
 var HYPERCERTS_DEFS_LEXICON_JSON = {
-	lexicon: lexicon$1,
-	id: id$g,
-	defs: defs$3
+	lexicon: lexicon$2,
+	id: id$i,
+	defs: defs$4
 };
 
-var lexicon = 1;
-var id$f = "org.hypercerts.funding.receipt";
-var defs$2 = {
+var lexicon$1 = 1;
+var id$h = "org.hypercerts.funding.receipt";
+var defs$3 = {
 	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.",
@@ -2014,13 +2340,104 @@ var defs$2 = {
 	}
 };
 var FUNDING_RECEIPT_LEXICON_JSON = {
+	lexicon: lexicon$1,
+	id: id$h,
+	defs: defs$3
+};
+
+var lexicon = 1;
+var id$g = "org.hypercerts.helper.workScopeTag";
+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.",
+		key: "tid",
+		record: {
+			type: "object",
+			required: [
+				"createdAt",
+				"key",
+				"label"
+			],
+			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').",
+					maxLength: 120
+				},
+				label: {
+					type: "string",
+					description: "Human-readable label for this scope.",
+					maxLength: 200
+				},
+				kind: {
+					type: "string",
+					description: "Category type of this scope. Recommended values: topic, language, domain, method, tag.",
+					maxLength: 50
+				},
+				description: {
+					type: "string",
+					description: "Optional longer description of this scope.",
+					maxLength: 10000,
+					maxGraphemes: 1000
+				},
+				parent: {
+					type: "ref",
+					ref: "com.atproto.repo.strongRef",
+					description: "Optional strong reference to a parent scope record for taxonomy/hierarchy support."
+				},
+				aliases: {
+					type: "array",
+					items: {
+						type: "string",
+						maxLength: 200
+					},
+					maxLength: 50,
+					description: "Optional array of alternative names or identifiers for this scope."
+				},
+				externalReference: {
+					type: "union",
+					refs: [
+						"org.hypercerts.defs#uri",
+						"org.hypercerts.defs#smallBlob"
+					],
+					description: "Optional external reference for this scope as a URI or blob."
+				}
+			}
+		}
+	}
+};
+var HELPER_WORKSCOPETAG_LEXICON_JSON = {
 	lexicon: lexicon,
-	id: id$f,
+	id: id$g,
 	defs: defs$2
 };
 
-const is$typed$e = is$typed$f, validate$e = validate$f;
-const id$e = 'app.certified.badge.award';
+const is$typed$f = is$typed$g, validate$f = validate$g;
+const id$f = 'app.certified.badge.award';
+const hashMain$e = 'main';
+function isMain$e(v) {
+    return is$typed$f(v, id$f, hashMain$e);
+}
+function validateMain$e(v) {
+    return validate$f(v, id$f, hashMain$e, true);
+}
+
+var award = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$e,
+    isRecord: isMain$e,
+    validateMain: validateMain$e,
+    validateRecord: validateMain$e
+});
+
+const is$typed$e = is$typed$g, validate$e = validate$g;
+const id$e = 'app.certified.badge.definition';
 const hashMain$d = 'main';
 function isMain$d(v) {
     return is$typed$e(v, id$e, hashMain$d);
@@ -2029,7 +2446,7 @@ function validateMain$d(v) {
     return validate$e(v, id$e, hashMain$d, true);
 }
 
-var award = /*#__PURE__*/Object.freeze({
+var definition = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$d,
     isRecord: isMain$d,
@@ -2037,8 +2454,8 @@ var award = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$d
 });
 
-const is$typed$d = is$typed$f, validate$d = validate$f;
-const id$d = 'app.certified.badge.definition';
+const is$typed$d = is$typed$g, validate$d = validate$g;
+const id$d = 'app.certified.badge.response';
 const hashMain$c = 'main';
 function isMain$c(v) {
     return is$typed$d(v, id$d, hashMain$c);
@@ -2047,7 +2464,7 @@ function validateMain$c(v) {
     return validate$d(v, id$d, hashMain$c, true);
 }
 
-var definition = /*#__PURE__*/Object.freeze({
+var response = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$c,
     isRecord: isMain$c,
@@ -2055,8 +2472,12 @@ var definition = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$c
 });
 
-const is$typed$c = is$typed$f, validate$c = validate$f;
-const id$c = 'app.certified.badge.response';
+var defs$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null
+});
+
+const is$typed$c = is$typed$g, validate$c = validate$g;
+const id$c = 'app.certified.location';
 const hashMain$b = 'main';
 function isMain$b(v) {
     return is$typed$c(v, id$c, hashMain$b);
@@ -2065,7 +2486,7 @@ function validateMain$b(v) {
     return validate$c(v, id$c, hashMain$b, true);
 }
 
-var response = /*#__PURE__*/Object.freeze({
+var location = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$b,
     isRecord: isMain$b,
@@ -2073,46 +2494,51 @@ var response = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$b
 });
 
-var defs$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null
-});
-
-const is$typed$b = is$typed$f, validate$b = validate$f;
-const id$b = 'app.certified.location';
+const is$typed$b = is$typed$g, validate$b = validate$g;
+const id$b = 'com.atproto.repo.strongRef';
 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);
+    return validate$b(v, id$b, hashMain$a);
 }
 
-var location = /*#__PURE__*/Object.freeze({
+var strongRef = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$a,
-    isRecord: isMain$a,
-    validateMain: validateMain$a,
-    validateRecord: validateMain$a
+    validateMain: validateMain$a
 });
 
-const is$typed$a = is$typed$f, validate$a = validate$f;
-const id$a = 'com.atproto.repo.strongRef';
+const is$typed$a = is$typed$g, validate$a = validate$g;
+const id$a = 'org.hypercerts.claim.activity';
 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);
+    return validate$a(v, id$a, hashMain$9, true);
+}
+const hashContributor = 'contributor';
+function isContributor(v) {
+    return is$typed$a(v, id$a, hashContributor);
+}
+function validateContributor(v) {
+    return validate$a(v, id$a, hashContributor);
 }
 
-var strongRef = /*#__PURE__*/Object.freeze({
+var activity = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    isContributor: isContributor,
     isMain: isMain$9,
-    validateMain: validateMain$9
+    isRecord: isMain$9,
+    validateContributor: validateContributor,
+    validateMain: validateMain$9,
+    validateRecord: validateMain$9
 });
 
-const is$typed$9 = is$typed$f, validate$9 = validate$f;
-const id$9 = 'org.hypercerts.claim.activity';
+const is$typed$9 = is$typed$g, validate$9 = validate$g;
+const id$9 = 'org.hypercerts.claim.collection';
 const hashMain$8 = 'main';
 function isMain$8(v) {
     return is$typed$9(v, id$9, hashMain$8);
@@ -2120,35 +2546,26 @@ function isMain$8(v) {
 function validateMain$8(v) {
     return validate$9(v, id$9, hashMain$8, true);
 }
-const hashContributor = 'contributor';
-function isContributor(v) {
-    return is$typed$9(v, id$9, hashContributor);
-}
-function validateContributor(v) {
-    return validate$9(v, id$9, hashContributor);
-}
-const hashActivityWeight = 'activityWeight';
-function isActivityWeight(v) {
-    return is$typed$9(v, id$9, hashActivityWeight);
+const hashItem = 'item';
+function isItem(v) {
+    return is$typed$9(v, id$9, hashItem);
 }
-function validateActivityWeight(v) {
-    return validate$9(v, id$9, hashActivityWeight);
+function validateItem(v) {
+    return validate$9(v, id$9, hashItem);
 }
 
-var activity = /*#__PURE__*/Object.freeze({
+var collection = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    isActivityWeight: isActivityWeight,
-    isContributor: isContributor,
+    isItem: isItem,
     isMain: isMain$8,
     isRecord: isMain$8,
-    validateActivityWeight: validateActivityWeight,
-    validateContributor: validateContributor,
+    validateItem: validateItem,
     validateMain: validateMain$8,
     validateRecord: validateMain$8
 });
 
-const is$typed$8 = is$typed$f, validate$8 = validate$f;
-const id$8 = 'org.hypercerts.claim.collection';
+const is$typed$8 = is$typed$g, validate$8 = validate$g;
+const id$8 = 'org.hypercerts.claim.contributionDetails';
 const hashMain$7 = 'main';
 function isMain$7(v) {
     return is$typed$8(v, id$8, hashMain$7);
@@ -2157,7 +2574,7 @@ function validateMain$7(v) {
     return validate$8(v, id$8, hashMain$7, true);
 }
 
-var collection = /*#__PURE__*/Object.freeze({
+var contributionDetails = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$7,
     isRecord: isMain$7,
@@ -2165,8 +2582,8 @@ var collection = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$7
 });
 
-const is$typed$7 = is$typed$f, validate$7 = validate$f;
-const id$7 = 'org.hypercerts.claim.contributionDetails';
+const is$typed$7 = is$typed$g, validate$7 = validate$g;
+const id$7 = 'org.hypercerts.claim.contributorInformation';
 const hashMain$6 = 'main';
 function isMain$6(v) {
     return is$typed$7(v, id$7, hashMain$6);
@@ -2175,7 +2592,7 @@ function validateMain$6(v) {
     return validate$7(v, id$7, hashMain$6, true);
 }
 
-var contributionDetails = /*#__PURE__*/Object.freeze({
+var contributorInformation = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$6,
     isRecord: isMain$6,
@@ -2183,8 +2600,15 @@ var contributionDetails = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$6
 });
 
-const is$typed$6 = is$typed$f, validate$6 = validate$f;
-const id$6 = 'org.hypercerts.claim.contributorInformation';
+const is$typed$6 = is$typed$g, validate$6 = validate$g;
+const id$6 = 'org.hypercerts.claim.evaluation';
+const hashScore = 'score';
+function isScore(v) {
+    return is$typed$6(v, id$6, hashScore);
+}
+function validateScore(v) {
+    return validate$6(v, id$6, hashScore);
+}
 const hashMain$5 = 'main';
 function isMain$5(v) {
     return is$typed$6(v, id$6, hashMain$5);
@@ -2193,23 +2617,18 @@ function validateMain$5(v) {
     return validate$6(v, id$6, hashMain$5, true);
 }
 
-var contributorInformation = /*#__PURE__*/Object.freeze({
+var evaluation = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$5,
     isRecord: isMain$5,
+    isScore: isScore,
     validateMain: validateMain$5,
-    validateRecord: validateMain$5
+    validateRecord: validateMain$5,
+    validateScore: validateScore
 });
 
-const is$typed$5 = is$typed$f, validate$5 = validate$f;
-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$g, validate$5 = validate$g;
+const id$5 = 'org.hypercerts.claim.evidence';
 const hashMain$4 = 'main';
 function isMain$4(v) {
     return is$typed$5(v, id$5, hashMain$4);
@@ -2218,18 +2637,16 @@ function validateMain$4(v) {
     return validate$5(v, id$5, hashMain$4, true);
 }
 
-var evaluation = /*#__PURE__*/Object.freeze({
+var evidence = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$4,
     isRecord: isMain$4,
-    isScore: isScore,
     validateMain: validateMain$4,
-    validateRecord: validateMain$4,
-    validateScore: validateScore
+    validateRecord: validateMain$4
 });
 
-const is$typed$4 = is$typed$f, validate$4 = validate$f;
-const id$4 = 'org.hypercerts.claim.evidence';
+const is$typed$4 = is$typed$g, validate$4 = validate$g;
+const id$4 = 'org.hypercerts.claim.measurement';
 const hashMain$3 = 'main';
 function isMain$3(v) {
     return is$typed$4(v, id$4, hashMain$3);
@@ -2238,7 +2655,7 @@ function validateMain$3(v) {
     return validate$4(v, id$4, hashMain$3, true);
 }
 
-var evidence = /*#__PURE__*/Object.freeze({
+var measurement = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$3,
     isRecord: isMain$3,
@@ -2246,8 +2663,8 @@ var evidence = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$3
 });
 
-const is$typed$3 = is$typed$f, validate$3 = validate$f;
-const id$3 = 'org.hypercerts.claim.measurement';
+const is$typed$3 = is$typed$g, validate$3 = validate$g;
+const id$3 = 'org.hypercerts.claim.rights';
 const hashMain$2 = 'main';
 function isMain$2(v) {
     return is$typed$3(v, id$3, hashMain$2);
@@ -2256,7 +2673,7 @@ function validateMain$2(v) {
     return validate$3(v, id$3, hashMain$2, true);
 }
 
-var measurement = /*#__PURE__*/Object.freeze({
+var rights = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain$2,
     isRecord: isMain$2,
@@ -2264,60 +2681,70 @@ var measurement = /*#__PURE__*/Object.freeze({
     validateRecord: validateMain$2
 });
 
-const is$typed$2 = is$typed$f, validate$2 = validate$f;
-const id$2 = 'org.hypercerts.claim.rights';
-const hashMain$1 = 'main';
-function isMain$1(v) {
-    return is$typed$2(v, id$2, hashMain$1);
-}
-function validateMain$1(v) {
-    return validate$2(v, id$2, hashMain$1, true);
-}
-
-var rights = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    isMain: isMain$1,
-    isRecord: isMain$1,
-    validateMain: validateMain$1,
-    validateRecord: validateMain$1
-});
-
-const is$typed$1 = is$typed$f, validate$1 = validate$f;
-const id$1 = 'org.hypercerts.defs';
+const is$typed$2 = is$typed$g, validate$2 = validate$g;
+const id$2 = 'org.hypercerts.defs';
 const hashUri = 'uri';
 function isUri(v) {
-    return is$typed$1(v, id$1, hashUri);
+    return is$typed$2(v, id$2, hashUri);
 }
 function validateUri(v) {
-    return validate$1(v, id$1, hashUri);
+    return validate$2(v, id$2, hashUri);
 }
 const hashSmallBlob = 'smallBlob';
 function isSmallBlob(v) {
-    return is$typed$1(v, id$1, hashSmallBlob);
+    return is$typed$2(v, id$2, hashSmallBlob);
 }
 function validateSmallBlob(v) {
-    return validate$1(v, id$1, hashSmallBlob);
+    return validate$2(v, id$2, hashSmallBlob);
 }
 const hashLargeBlob = 'largeBlob';
 function isLargeBlob(v) {
-    return is$typed$1(v, id$1, hashLargeBlob);
+    return is$typed$2(v, id$2, hashLargeBlob);
 }
 function validateLargeBlob(v) {
-    return validate$1(v, id$1, hashLargeBlob);
+    return validate$2(v, id$2, hashLargeBlob);
 }
 const hashSmallImage = 'smallImage';
 function isSmallImage(v) {
-    return is$typed$1(v, id$1, hashSmallImage);
+    return is$typed$2(v, id$2, hashSmallImage);
 }
 function validateSmallImage(v) {
-    return validate$1(v, id$1, hashSmallImage);
+    return validate$2(v, id$2, hashSmallImage);
 }
 const hashLargeImage = 'largeImage';
 function isLargeImage(v) {
-    return is$typed$1(v, id$1, hashLargeImage);
+    return is$typed$2(v, id$2, hashLargeImage);
 }
 function validateLargeImage(v) {
-    return validate$1(v, id$1, hashLargeImage);
+    return validate$2(v, id$2, hashLargeImage);
+}
+const hashWorkScopeAll = 'workScopeAll';
+function isWorkScopeAll(v) {
+    return is$typed$2(v, id$2, hashWorkScopeAll);
+}
+function validateWorkScopeAll(v) {
+    return validate$2(v, id$2, hashWorkScopeAll);
+}
+const hashWorkScopeAny = 'workScopeAny';
+function isWorkScopeAny(v) {
+    return is$typed$2(v, id$2, hashWorkScopeAny);
+}
+function validateWorkScopeAny(v) {
+    return validate$2(v, id$2, hashWorkScopeAny);
+}
+const hashWorkScopeNot = 'workScopeNot';
+function isWorkScopeNot(v) {
+    return is$typed$2(v, id$2, hashWorkScopeNot);
+}
+function validateWorkScopeNot(v) {
+    return validate$2(v, id$2, hashWorkScopeNot);
+}
+const hashWorkScopeAtom = 'workScopeAtom';
+function isWorkScopeAtom(v) {
+    return is$typed$2(v, id$2, hashWorkScopeAtom);
+}
+function validateWorkScopeAtom(v) {
+    return validate$2(v, id$2, hashWorkScopeAtom);
 }
 
 var defs = /*#__PURE__*/Object.freeze({
@@ -2327,15 +2754,41 @@ var defs = /*#__PURE__*/Object.freeze({
     isSmallBlob: isSmallBlob,
     isSmallImage: isSmallImage,
     isUri: isUri,
+    isWorkScopeAll: isWorkScopeAll,
+    isWorkScopeAny: isWorkScopeAny,
+    isWorkScopeAtom: isWorkScopeAtom,
+    isWorkScopeNot: isWorkScopeNot,
     validateLargeBlob: validateLargeBlob,
     validateLargeImage: validateLargeImage,
     validateSmallBlob: validateSmallBlob,
     validateSmallImage: validateSmallImage,
-    validateUri: validateUri
+    validateUri: validateUri,
+    validateWorkScopeAll: validateWorkScopeAll,
+    validateWorkScopeAny: validateWorkScopeAny,
+    validateWorkScopeAtom: validateWorkScopeAtom,
+    validateWorkScopeNot: validateWorkScopeNot
 });
 
-const is$typed = is$typed$f, validate = validate$f;
-const id = 'org.hypercerts.funding.receipt';
+const is$typed$1 = is$typed$g, validate$1 = validate$g;
+const id$1 = 'org.hypercerts.funding.receipt';
+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);
+}
+
+var receipt = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isMain: isMain$1,
+    isRecord: isMain$1,
+    validateMain: validateMain$1,
+    validateRecord: validateMain$1
+});
+
+const is$typed = is$typed$g, validate = validate$g;
+const id = 'org.hypercerts.helper.workScopeTag';
 const hashMain = 'main';
 function isMain(v) {
     return is$typed(v, id, hashMain);
@@ -2344,7 +2797,7 @@ function validateMain(v) {
     return validate(v, id, hashMain, true);
 }
 
-var receipt = /*#__PURE__*/Object.freeze({
+var workScopeTag = /*#__PURE__*/Object.freeze({
     __proto__: null,
     isMain: isMain,
     isRecord: isMain,
@@ -2358,7 +2811,7 @@ var receipt = /*#__PURE__*/Object.freeze({
  * ⚠️  DO NOT EDIT THIS FILE MANUALLY ⚠️
  *
  * This file is automatically generated by scripts/generate-exports.js
- * Generated: 2026-01-21T07:15:37.790Z
+ * Generated: 2026-01-21T23:19:57.583Z
  *
  * To regenerate this file, run:
  *   npm run gen-api
@@ -2391,6 +2844,7 @@ const MEASUREMENT_NSID = "org.hypercerts.claim.measurement";
 const RIGHTS_NSID = "org.hypercerts.claim.rights";
 const HYPERCERTS_DEFS_NSID = "org.hypercerts.defs";
 const FUNDING_RECEIPT_NSID = "org.hypercerts.funding.receipt";
+const HELPER_WORKSCOPETAG_NSID = "org.hypercerts.helper.workScopeTag";
 /**
  * Collection NSIDs organized by semantic record type.
  *
@@ -2414,6 +2868,7 @@ const HYPERCERTS_NSIDS = {
     RIGHTS: RIGHTS_NSID,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_NSID,
     FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
+    HELPER_WORKSCOPETAG: HELPER_WORKSCOPETAG_NSID,
 };
 /**
  * Lexicon JSON objects organized by semantic record type.
@@ -2435,6 +2890,7 @@ const HYPERCERTS_LEXICON_JSON = {
     RIGHTS: RIGHTS_LEXICON_JSON,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_JSON,
     FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_JSON,
+    HELPER_WORKSCOPETAG: HELPER_WORKSCOPETAG_LEXICON_JSON,
 };
 // Individual lexicon objects (from lexicons.get())
 const BADGE_AWARD_LEXICON_DOC = lexicons.get(BADGE_AWARD_NSID);
@@ -2453,6 +2909,7 @@ const MEASUREMENT_LEXICON_DOC = lexicons.get(MEASUREMENT_NSID);
 const RIGHTS_LEXICON_DOC = lexicons.get(RIGHTS_NSID);
 const HYPERCERTS_DEFS_LEXICON_DOC = lexicons.get(HYPERCERTS_DEFS_NSID);
 const FUNDING_RECEIPT_LEXICON_DOC = lexicons.get(FUNDING_RECEIPT_NSID);
+const HELPER_WORKSCOPETAG_LEXICON_DOC = lexicons.get(HELPER_WORKSCOPETAG_NSID);
 /**
  * Lexicon document objects organized by semantic record type.
  */
@@ -2473,7 +2930,8 @@ const HYPERCERTS_LEXICON_DOC = {
     RIGHTS: RIGHTS_LEXICON_DOC,
     HYPERCERTS_DEFS: HYPERCERTS_DEFS_LEXICON_DOC,
     FUNDING_RECEIPT: FUNDING_RECEIPT_LEXICON_DOC,
+    HELPER_WORKSCOPETAG: HELPER_WORKSCOPETAG_LEXICON_DOC,
 };
 
-export { ACTIVITY_LEXICON_DOC, ACTIVITY_LEXICON_JSON, ACTIVITY_NSID, award as AppCertifiedBadgeAward, definition as AppCertifiedBadgeDefinition, response as AppCertifiedBadgeResponse, defs$1 as AppCertifiedDefs, location as AppCertifiedLocation, BADGE_AWARD_LEXICON_DOC, BADGE_AWARD_LEXICON_JSON, BADGE_AWARD_NSID, BADGE_DEFINITION_LEXICON_DOC, BADGE_DEFINITION_LEXICON_JSON, BADGE_DEFINITION_NSID, BADGE_RESPONSE_LEXICON_DOC, BADGE_RESPONSE_LEXICON_JSON, BADGE_RESPONSE_NSID, CERTIFIED_DEFS_LEXICON_DOC, CERTIFIED_DEFS_LEXICON_JSON, CERTIFIED_DEFS_NSID, COLLECTION_LEXICON_DOC, COLLECTION_LEXICON_JSON, COLLECTION_NSID, CONTRIBUTIONDETAILS_LEXICON_DOC, CONTRIBUTIONDETAILS_LEXICON_JSON, CONTRIBUTIONDETAILS_NSID, CONTRIBUTORINFORMATION_LEXICON_DOC, CONTRIBUTORINFORMATION_LEXICON_JSON, CONTRIBUTORINFORMATION_NSID, strongRef as ComAtprotoRepoStrongRef, EVALUATION_LEXICON_DOC, EVALUATION_LEXICON_JSON, EVALUATION_NSID, EVIDENCE_LEXICON_DOC, EVIDENCE_LEXICON_JSON, EVIDENCE_NSID, FUNDING_RECEIPT_LEXICON_DOC, FUNDING_RECEIPT_LEXICON_JSON, FUNDING_RECEIPT_NSID, HYPERCERTS_DEFS_LEXICON_DOC, HYPERCERTS_DEFS_LEXICON_JSON, HYPERCERTS_DEFS_NSID, HYPERCERTS_LEXICON_DOC, HYPERCERTS_LEXICON_JSON, HYPERCERTS_NSIDS, ids as HYPERCERTS_NSIDS_BY_TYPE, schemas as HYPERCERTS_SCHEMAS, schemaDict as HYPERCERTS_SCHEMA_DICT, LOCATION_LEXICON_DOC, LOCATION_LEXICON_JSON, LOCATION_NSID, MEASUREMENT_LEXICON_DOC, MEASUREMENT_LEXICON_JSON, MEASUREMENT_NSID, activity as OrgHypercertsClaimActivity, collection as OrgHypercertsClaimCollection, contributionDetails as OrgHypercertsClaimContributionDetails, contributorInformation as OrgHypercertsClaimContributorInformation, evaluation as OrgHypercertsClaimEvaluation, evidence as OrgHypercertsClaimEvidence, measurement as OrgHypercertsClaimMeasurement, rights as OrgHypercertsClaimRights, defs as OrgHypercertsDefs, receipt as OrgHypercertsFundingReceipt, RIGHTS_LEXICON_DOC, RIGHTS_LEXICON_JSON, RIGHTS_NSID, STRONGREF_LEXICON_DOC, STRONGREF_LEXICON_JSON, STRONGREF_NSID, asPredicate, is$typed$f as is$typed, lexicons, maybe$typed, validate$f as validate };
+export { ACTIVITY_LEXICON_DOC, ACTIVITY_LEXICON_JSON, ACTIVITY_NSID, award as AppCertifiedBadgeAward, definition as AppCertifiedBadgeDefinition, response as AppCertifiedBadgeResponse, defs$1 as AppCertifiedDefs, location as AppCertifiedLocation, BADGE_AWARD_LEXICON_DOC, BADGE_AWARD_LEXICON_JSON, BADGE_AWARD_NSID, BADGE_DEFINITION_LEXICON_DOC, BADGE_DEFINITION_LEXICON_JSON, BADGE_DEFINITION_NSID, BADGE_RESPONSE_LEXICON_DOC, BADGE_RESPONSE_LEXICON_JSON, BADGE_RESPONSE_NSID, CERTIFIED_DEFS_LEXICON_DOC, CERTIFIED_DEFS_LEXICON_JSON, CERTIFIED_DEFS_NSID, COLLECTION_LEXICON_DOC, COLLECTION_LEXICON_JSON, COLLECTION_NSID, CONTRIBUTIONDETAILS_LEXICON_DOC, CONTRIBUTIONDETAILS_LEXICON_JSON, CONTRIBUTIONDETAILS_NSID, CONTRIBUTORINFORMATION_LEXICON_DOC, CONTRIBUTORINFORMATION_LEXICON_JSON, CONTRIBUTORINFORMATION_NSID, strongRef as ComAtprotoRepoStrongRef, EVALUATION_LEXICON_DOC, EVALUATION_LEXICON_JSON, EVALUATION_NSID, EVIDENCE_LEXICON_DOC, EVIDENCE_LEXICON_JSON, EVIDENCE_NSID, FUNDING_RECEIPT_LEXICON_DOC, FUNDING_RECEIPT_LEXICON_JSON, FUNDING_RECEIPT_NSID, HELPER_WORKSCOPETAG_LEXICON_DOC, HELPER_WORKSCOPETAG_LEXICON_JSON, HELPER_WORKSCOPETAG_NSID, HYPERCERTS_DEFS_LEXICON_DOC, HYPERCERTS_DEFS_LEXICON_JSON, HYPERCERTS_DEFS_NSID, HYPERCERTS_LEXICON_DOC, HYPERCERTS_LEXICON_JSON, HYPERCERTS_NSIDS, ids as HYPERCERTS_NSIDS_BY_TYPE, schemas as HYPERCERTS_SCHEMAS, schemaDict as HYPERCERTS_SCHEMA_DICT, LOCATION_LEXICON_DOC, LOCATION_LEXICON_JSON, LOCATION_NSID, MEASUREMENT_LEXICON_DOC, MEASUREMENT_LEXICON_JSON, MEASUREMENT_NSID, activity as OrgHypercertsClaimActivity, collection as OrgHypercertsClaimCollection, contributionDetails as OrgHypercertsClaimContributionDetails, contributorInformation as OrgHypercertsClaimContributorInformation, evaluation as OrgHypercertsClaimEvaluation, evidence as OrgHypercertsClaimEvidence, measurement as OrgHypercertsClaimMeasurement, rights as OrgHypercertsClaimRights, defs as OrgHypercertsDefs, receipt as OrgHypercertsFundingReceipt, workScopeTag as OrgHypercertsHelperWorkScopeTag, RIGHTS_LEXICON_DOC, RIGHTS_LEXICON_JSON, RIGHTS_NSID, STRONGREF_LEXICON_DOC, STRONGREF_LEXICON_JSON, STRONGREF_NSID, asPredicate, is$typed$g as is$typed, lexicons, maybe$typed, validate$g as validate };
 //# sourceMappingURL=index.mjs.map