@hypercerts-org/sdk-core 0.10.0-beta.0 → 0.10.0-beta.1

package/dist/index.cjs

@@ -2,10 +2,10 @@
 
 var oauthClientNode = require('@atproto/oauth-client-node');
 var zod = require('zod');
-var lexicon$1 = require('@atproto/lexicon');
-var lexicon = require('@hypercerts-org/lexicon');
 var api = require('@atproto/api');
 var eventemitter3 = require('eventemitter3');
+var lexicon = require('@hypercerts-org/lexicon');
+require('@atproto/lexicon');
 
 /**
  * Base error class for all SDK errors.
@@ -2004,303 +2004,6 @@ class OAuthClient {
     }
 }
 
-/**
- * Registry for managing and validating AT Protocol lexicon schemas.
- *
- * Lexicons are schema definitions that describe the structure of records
- * in the AT Protocol. This registry allows you to:
- *
- * - Register custom lexicons for your application's record types
- * - Validate records against their lexicon schemas
- * - Extend the AT Protocol Agent with custom lexicon support
- *
- * @remarks
- * The SDK automatically registers hypercert lexicons when creating a Repository.
- * You only need to use this class directly if you're working with custom
- * record types.
- *
- * **Lexicon IDs** follow the NSID (Namespaced Identifier) format:
- * `{authority}.{name}` (e.g., `org.hypercerts.hypercert`)
- *
- * @example Registering custom lexicons
- * ```typescript
- * const registry = sdk.getLexiconRegistry();
- *
- * // Register a single lexicon
- * registry.register({
- *   lexicon: 1,
- *   id: "org.example.myRecord",
- *   defs: {
- *     main: {
- *       type: "record",
- *       key: "tid",
- *       record: {
- *         type: "object",
- *         required: ["title", "createdAt"],
- *         properties: {
- *           title: { type: "string" },
- *           description: { type: "string" },
- *           createdAt: { type: "string", format: "datetime" },
- *         },
- *       },
- *     },
- *   },
- * });
- *
- * // Register multiple lexicons at once
- * registry.registerMany([lexicon1, lexicon2, lexicon3]);
- * ```
- *
- * @example Validating records
- * ```typescript
- * const result = registry.validate("org.example.myRecord", {
- *   title: "Test",
- *   createdAt: new Date().toISOString(),
- * });
- *
- * if (!result.valid) {
- *   console.error(`Validation failed: ${result.error}`);
- * }
- * ```
- *
- * @see https://atproto.com/specs/lexicon for the Lexicon specification
- */
-class LexiconRegistry {
-    /**
-     * Creates a new LexiconRegistry.
-     *
-     * The registry starts empty. Use {@link register} or {@link registerMany}
-     * to add lexicons.
-     */
-    constructor() {
-        /** Map of lexicon ID to lexicon document */
-        this.lexicons = new Map();
-        this.lexiconsCollection = new lexicon$1.Lexicons();
-    }
-    /**
-     * Registers a single lexicon schema.
-     *
-     * @param lexicon - The lexicon document to register
-     * @throws {@link ValidationError} if the lexicon doesn't have an `id` field
-     *
-     * @remarks
-     * If a lexicon with the same ID is already registered, it will be
-     * replaced with the new definition. This is useful for testing but
-     * should generally be avoided in production.
-     *
-     * @example
-     * ```typescript
-     * registry.register({
-     *   lexicon: 1,
-     *   id: "org.example.post",
-     *   defs: {
-     *     main: {
-     *       type: "record",
-     *       key: "tid",
-     *       record: {
-     *         type: "object",
-     *         required: ["text", "createdAt"],
-     *         properties: {
-     *           text: { type: "string", maxLength: 300 },
-     *           createdAt: { type: "string", format: "datetime" },
-     *         },
-     *       },
-     *     },
-     *   },
-     * });
-     * ```
-     */
-    register(lexicon) {
-        if (!lexicon.id) {
-            throw new ValidationError("Lexicon must have an 'id' field");
-        }
-        // Remove existing lexicon if present (to allow overwriting)
-        if (this.lexicons.has(lexicon.id)) {
-            // Lexicons collection doesn't support removal, so we create a new one
-            // This is a limitation - in practice, lexicons shouldn't be overwritten
-            // But we allow it for testing and flexibility
-            const existingLexicon = this.lexicons.get(lexicon.id);
-            if (existingLexicon) {
-                // Try to remove from collection (may fail if not supported)
-                try {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    this.lexiconsCollection.remove?.(lexicon.id);
-                }
-                catch {
-                    // If removal fails, create a new collection
-                    this.lexiconsCollection = new lexicon$1.Lexicons();
-                    // Re-register all other lexicons
-                    for (const [id, lex] of this.lexicons.entries()) {
-                        if (id !== lexicon.id) {
-                            this.lexiconsCollection.add(lex);
-                        }
-                    }
-                }
-            }
-        }
-        this.lexicons.set(lexicon.id, lexicon);
-        this.lexiconsCollection.add(lexicon);
-    }
-    /**
-     * Registers multiple lexicons at once.
-     *
-     * @param lexicons - Array of lexicon documents to register
-     *
-     * @example
-     * ```typescript
-     * import { HYPERCERT_LEXICONS } from "@hypercerts-org/sdk/lexicons";
-     *
-     * registry.registerMany(HYPERCERT_LEXICONS);
-     * ```
-     */
-    registerMany(lexicons) {
-        for (const lexicon of lexicons) {
-            this.register(lexicon);
-        }
-    }
-    /**
-     * Gets a lexicon document by ID.
-     *
-     * @param id - The lexicon NSID (e.g., "org.hypercerts.hypercert")
-     * @returns The lexicon document, or `undefined` if not registered
-     *
-     * @example
-     * ```typescript
-     * const lexicon = registry.get("org.hypercerts.hypercert");
-     * if (lexicon) {
-     *   console.log(`Found lexicon: ${lexicon.id}`);
-     * }
-     * ```
-     */
-    get(id) {
-        return this.lexicons.get(id);
-    }
-    /**
-     * Validates a record against a collection's lexicon schema.
-     *
-     * @param collection - The collection NSID (same as lexicon ID)
-     * @param record - The record data to validate
-     * @returns Validation result with `valid` boolean and optional `error` message
-     *
-     * @remarks
-     * - If no lexicon is registered for the collection, validation passes
-     *   (we can't validate against unknown schemas)
-     * - Validation checks required fields and type constraints defined
-     *   in the lexicon schema
-     *
-     * @example
-     * ```typescript
-     * const result = registry.validate("org.hypercerts.hypercert", {
-     *   title: "My Hypercert",
-     *   description: "Description...",
-     *   // ... other fields
-     * });
-     *
-     * if (!result.valid) {
-     *   throw new Error(`Invalid record: ${result.error}`);
-     * }
-     * ```
-     */
-    validate(collection, record) {
-        // Check if we have a lexicon registered for this collection
-        // Collection format is typically "namespace.collection" (e.g., "app.bsky.feed.post")
-        // Lexicon ID format is the same
-        const lexiconId = collection;
-        const lexicon = this.lexicons.get(lexiconId);
-        if (!lexicon) {
-            // No lexicon registered - validation passes (can't validate unknown schemas)
-            return { valid: true };
-        }
-        // Check required fields if the lexicon defines them
-        const recordDef = lexicon.defs?.record;
-        if (recordDef && typeof recordDef === "object" && "record" in recordDef) {
-            const recordSchema = recordDef.record;
-            if (typeof recordSchema === "object" && "required" in recordSchema && Array.isArray(recordSchema.required)) {
-                const recordObj = record;
-                for (const requiredField of recordSchema.required) {
-                    if (typeof requiredField === "string" && !(requiredField in recordObj)) {
-                        return {
-                            valid: false,
-                            error: `Missing required field: ${requiredField}`,
-                        };
-                    }
-                }
-            }
-        }
-        try {
-            this.lexiconsCollection.assertValidRecord(collection, record);
-            return { valid: true };
-        }
-        catch (error) {
-            // If error indicates lexicon not found, treat as validation pass
-            // (the lexicon might exist in Agent's collection but not ours)
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (errorMessage.includes("not found") || errorMessage.includes("Lexicon not found")) {
-                return { valid: true };
-            }
-            return {
-                valid: false,
-                error: errorMessage,
-            };
-        }
-    }
-    /**
-     * Adds all registered lexicons to an AT Protocol Agent instance.
-     *
-     * This allows the Agent to understand custom lexicon types when making
-     * API requests.
-     *
-     * @param agent - The Agent instance to extend
-     *
-     * @remarks
-     * This is called automatically when creating a Repository. You typically
-     * don't need to call this directly unless you're using the Agent
-     * independently.
-     *
-     * @internal
-     */
-    addToAgent(agent) {
-        // Access the internal lexicons collection and merge our lexicons
-        // The Agent's lex property is a Lexicons instance
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const agentLex = agent.lex;
-        // Add each registered lexicon to the agent
-        for (const lexicon of this.lexicons.values()) {
-            agentLex.add(lexicon);
-        }
-    }
-    /**
-     * Gets all registered lexicon IDs.
-     *
-     * @returns Array of lexicon NSIDs
-     *
-     * @example
-     * ```typescript
-     * const ids = registry.getRegisteredIds();
-     * console.log(`Registered lexicons: ${ids.join(", ")}`);
-     * ```
-     */
-    getRegisteredIds() {
-        return Array.from(this.lexicons.keys());
-    }
-    /**
-     * Checks if a lexicon is registered.
-     *
-     * @param id - The lexicon NSID to check
-     * @returns `true` if the lexicon is registered
-     *
-     * @example
-     * ```typescript
-     * if (registry.has("org.hypercerts.hypercert")) {
-     *   // Hypercert lexicon is available
-     * }
-     * ```
-     */
-    has(id) {
-        return this.lexicons.has(id);
-    }
-}
-
 /**
  * ConfigurableAgent - Agent with configurable service URL routing.
  *
@@ -2429,14 +2132,12 @@ class RecordOperationsImpl {
      *
      * @param agent - AT Protocol Agent for making API calls
      * @param repoDid - DID of the repository to operate on
-     * @param lexiconRegistry - Registry for record validation
      *
      * @internal
      */
-    constructor(agent, repoDid, lexiconRegistry) {
+    constructor(agent, repoDid) {
         this.agent = agent;
         this.repoDid = repoDid;
-        this.lexiconRegistry = lexiconRegistry;
     }
     /**
      * Creates a new record in the specified collection.
@@ -2472,10 +2173,6 @@ class RecordOperationsImpl {
      * ```
      */
     async create(params) {
-        const validation = this.lexiconRegistry.validate(params.collection, params.record);
-        if (!validation.valid) {
-            throw new ValidationError(`Invalid record for collection ${params.collection}: ${validation.error}`);
-        }
         try {
             const result = await this.agent.com.atproto.repo.createRecord({
                 repo: this.repoDid,
@@ -2530,10 +2227,6 @@ class RecordOperationsImpl {
      * ```
      */
     async update(params) {
-        const validation = this.lexiconRegistry.validate(params.collection, params.record);
-        if (!validation.valid) {
-            throw new ValidationError(`Invalid record for collection ${params.collection}: ${validation.error}`);
-        }
         try {
             const result = await this.agent.com.atproto.repo.putRecord({
                 repo: this.repoDid,
@@ -3125,6 +2818,148 @@ class ProfileOperationsImpl {
     }
 }
 
+/**
+ * Lexicons entrypoint - Lexicon definitions and registry.
+ *
+ * This sub-entrypoint exports the lexicon registry and hypercert
+ * lexicon constants for working with AT Protocol record schemas.
+ *
+ * @remarks
+ * Import from `@hypercerts-org/sdk/lexicons`:
+ *
+ * ```typescript
+ * import {
+ *   LexiconRegistry,
+ *   HYPERCERT_LEXICONS,
+ *   HYPERCERT_COLLECTIONS,
+ * } from "@hypercerts-org/sdk/lexicons";
+ * ```
+ *
+ * **Exports**:
+ * - {@link LexiconRegistry} - Registry for managing and validating lexicons
+ * - {@link HYPERCERT_LEXICONS} - Array of all hypercert lexicon documents
+ * - {@link HYPERCERT_COLLECTIONS} - Constants for collection NSIDs
+ *
+ * @example Using collection constants
+ * ```typescript
+ * import { HYPERCERT_COLLECTIONS } from "@hypercerts-org/sdk/lexicons";
+ *
+ * // List hypercerts using the correct collection name
+ * const records = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.RECORD,
+ * });
+ *
+ * // List contributions
+ * const contributions = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,
+ * });
+ * ```
+ *
+ * @example Custom lexicon registration
+ * ```typescript
+ * import { LexiconRegistry } from "@hypercerts-org/sdk/lexicons";
+ *
+ * const registry = sdk.getLexiconRegistry();
+ *
+ * // Register custom lexicon
+ * registry.register({
+ *   lexicon: 1,
+ *   id: "org.myapp.customRecord",
+ *   defs: { ... },
+ * });
+ *
+ * // Validate a record
+ * const result = registry.validate("org.myapp.customRecord", record);
+ * if (!result.valid) {
+ *   console.error(result.error);
+ * }
+ * ```
+ *
+ * @packageDocumentation
+ */
+/**
+ * All hypercert-related lexicons for registration with AT Protocol Agent.
+ * This array contains all lexicon documents from the published package.
+ */
+const HYPERCERT_LEXICONS = [
+    lexicon.CERTIFIED_DEFS_LEXICON_JSON,
+    lexicon.LOCATION_LEXICON_JSON,
+    lexicon.STRONGREF_LEXICON_JSON,
+    lexicon.HYPERCERTS_DEFS_LEXICON_JSON,
+    lexicon.ACTIVITY_LEXICON_JSON,
+    lexicon.COLLECTION_LEXICON_JSON,
+    lexicon.CONTRIBUTION_LEXICON_JSON,
+    lexicon.EVALUATION_LEXICON_JSON,
+    lexicon.EVIDENCE_LEXICON_JSON,
+    lexicon.MEASUREMENT_LEXICON_JSON,
+    lexicon.RIGHTS_LEXICON_JSON,
+    lexicon.PROJECT_LEXICON_JSON,
+    lexicon.BADGE_AWARD_LEXICON_JSON,
+    lexicon.BADGE_DEFINITION_LEXICON_JSON,
+    lexicon.BADGE_RESPONSE_LEXICON_JSON,
+    lexicon.FUNDING_RECEIPT_LEXICON_JSON,
+];
+/**
+ * Collection NSIDs (Namespaced Identifiers) for hypercert records.
+ *
+ * Use these constants when performing record operations to ensure
+ * correct collection names.
+ */
+const HYPERCERT_COLLECTIONS = {
+    /**
+     * Main hypercert claim record collection.
+     */
+    CLAIM: lexicon.ACTIVITY_NSID,
+    /**
+     * Rights record collection.
+     */
+    RIGHTS: lexicon.RIGHTS_NSID,
+    /**
+     * Location record collection (shared certified lexicon).
+     */
+    LOCATION: lexicon.LOCATION_NSID,
+    /**
+     * Contribution record collection.
+     */
+    CONTRIBUTION: lexicon.CONTRIBUTION_NSID,
+    /**
+     * Measurement record collection.
+     */
+    MEASUREMENT: lexicon.MEASUREMENT_NSID,
+    /**
+     * Evaluation record collection.
+     */
+    EVALUATION: lexicon.EVALUATION_NSID,
+    /**
+     * Evidence record collection.
+     */
+    EVIDENCE: lexicon.EVIDENCE_NSID,
+    /**
+     * Collection record collection (groups of hypercerts).
+     */
+    COLLECTION: lexicon.COLLECTION_NSID,
+    /**
+     * Project record collection.
+     */
+    PROJECT: lexicon.PROJECT_NSID,
+    /**
+     * Badge award record collection.
+     */
+    BADGE_AWARD: lexicon.BADGE_AWARD_NSID,
+    /**
+     * Badge definition record collection.
+     */
+    BADGE_DEFINITION: lexicon.BADGE_DEFINITION_NSID,
+    /**
+     * Badge response record collection.
+     */
+    BADGE_RESPONSE: lexicon.BADGE_RESPONSE_NSID,
+    /**
+     * Funding receipt record collection.
+     */
+    FUNDING_RECEIPT: lexicon.FUNDING_RECEIPT_NSID,
+};
+
 /**
  * HypercertOperationsImpl - High-level hypercert operations.
  *
@@ -3188,17 +3023,15 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
      * @param agent - AT Protocol Agent for making API calls
      * @param repoDid - DID of the repository to operate on
      * @param _serverUrl - Server URL (reserved for future use)
-     * @param lexiconRegistry - Registry for record validation
      * @param logger - Optional logger for debugging
      *
      * @internal
      */
-    constructor(agent, repoDid, _serverUrl, lexiconRegistry, logger) {
+    constructor(agent, repoDid, _serverUrl, logger) {
         super();
         this.agent = agent;
         this.repoDid = repoDid;
         this._serverUrl = _serverUrl;
-        this.lexiconRegistry = lexiconRegistry;
         this.logger = logger;
     }
     /**
@@ -3218,6 +3051,202 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
             }
         }
     }
+    /**
+     * Uploads an image blob and returns a blob reference.
+     *
+     * @param image - Image blob to upload
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to blob reference or undefined
+     * @throws {@link NetworkError} if upload fails
+     * @internal
+     */
+    async uploadImageBlob(image, onProgress) {
+        this.emitProgress(onProgress, { name: "uploadImage", status: "start" });
+        try {
+            const arrayBuffer = await image.arrayBuffer();
+            const uint8Array = new Uint8Array(arrayBuffer);
+            const uploadResult = await this.agent.com.atproto.repo.uploadBlob(uint8Array, {
+                encoding: image.type || "image/jpeg",
+            });
+            if (uploadResult.success) {
+                const blobRef = {
+                    $type: "blob",
+                    ref: { $link: uploadResult.data.blob.ref.toString() },
+                    mimeType: uploadResult.data.blob.mimeType,
+                    size: uploadResult.data.blob.size,
+                };
+                this.emitProgress(onProgress, {
+                    name: "uploadImage",
+                    status: "success",
+                    data: { size: image.size },
+                });
+                return blobRef;
+            }
+            throw new NetworkError("Image upload succeeded but returned no blob reference");
+        }
+        catch (error) {
+            this.emitProgress(onProgress, { name: "uploadImage", status: "error", error: error });
+            throw new NetworkError(`Failed to upload image: ${error instanceof Error ? error.message : "Unknown"}`, error);
+        }
+    }
+    /**
+     * Creates a rights record for a hypercert.
+     *
+     * @param rights - Rights data
+     * @param createdAt - ISO timestamp for creation
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to rights URI and CID
+     * @throws {@link ValidationError} if validation fails
+     * @throws {@link NetworkError} if creation fails
+     * @internal
+     */
+    async createRightsRecord(rights, createdAt, onProgress) {
+        this.emitProgress(onProgress, { name: "createRights", status: "start" });
+        const rightsRecord = {
+            $type: HYPERCERT_COLLECTIONS.RIGHTS,
+            rightsName: rights.name,
+            rightsType: rights.type,
+            rightsDescription: rights.description,
+            createdAt,
+        };
+        const rightsValidation = lexicon.validate(rightsRecord, HYPERCERT_COLLECTIONS.RIGHTS, "main", false);
+        if (!rightsValidation.success) {
+            throw new ValidationError(`Invalid rights record: ${rightsValidation.error?.message}`);
+        }
+        const rightsResult = await this.agent.com.atproto.repo.createRecord({
+            repo: this.repoDid,
+            collection: HYPERCERT_COLLECTIONS.RIGHTS,
+            record: rightsRecord,
+        });
+        if (!rightsResult.success) {
+            throw new NetworkError("Failed to create rights record");
+        }
+        const uri = rightsResult.data.uri;
+        const cid = rightsResult.data.cid;
+        this.emit("rightsCreated", { uri, cid });
+        this.emitProgress(onProgress, {
+            name: "createRights",
+            status: "success",
+            data: { uri },
+        });
+        return { uri, cid };
+    }
+    /**
+     * Creates the main hypercert record.
+     *
+     * @param params - Hypercert creation parameters
+     * @param rightsUri - URI of the associated rights record
+     * @param rightsCid - CID of the associated rights record
+     * @param imageBlobRef - Optional image blob reference
+     * @param createdAt - ISO timestamp for creation
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to hypercert URI and CID
+     * @throws {@link ValidationError} if validation fails
+     * @throws {@link NetworkError} if creation fails
+     * @internal
+     */
+    async createHypercertRecord(params, rightsUri, rightsCid, imageBlobRef, createdAt, onProgress) {
+        this.emitProgress(onProgress, { name: "createHypercert", status: "start" });
+        const hypercertRecord = {
+            $type: HYPERCERT_COLLECTIONS.CLAIM,
+            title: params.title,
+            shortDescription: params.shortDescription,
+            description: params.description,
+            workScope: params.workScope,
+            workTimeFrameFrom: params.workTimeFrameFrom,
+            workTimeFrameTo: params.workTimeFrameTo,
+            rights: { uri: rightsUri, cid: rightsCid },
+            createdAt,
+        };
+        if (imageBlobRef) {
+            hypercertRecord.image = imageBlobRef;
+        }
+        if (params.evidence && params.evidence.length > 0) {
+            hypercertRecord.evidence = params.evidence;
+        }
+        const hypercertValidation = lexicon.validate(hypercertRecord, HYPERCERT_COLLECTIONS.CLAIM, "#main", false);
+        if (!hypercertValidation.success) {
+            throw new ValidationError(`Invalid hypercert record: ${hypercertValidation.error?.message}`);
+        }
+        const hypercertResult = await this.agent.com.atproto.repo.createRecord({
+            repo: this.repoDid,
+            collection: HYPERCERT_COLLECTIONS.CLAIM,
+            record: hypercertRecord,
+        });
+        if (!hypercertResult.success) {
+            throw new NetworkError("Failed to create hypercert record");
+        }
+        const uri = hypercertResult.data.uri;
+        const cid = hypercertResult.data.cid;
+        this.emit("recordCreated", { uri, cid });
+        this.emitProgress(onProgress, {
+            name: "createHypercert",
+            status: "success",
+            data: { uri },
+        });
+        return { uri, cid };
+    }
+    /**
+     * Attaches a location to a hypercert with progress tracking.
+     *
+     * @param hypercertUri - URI of the hypercert
+     * @param location - Location data
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to location URI
+     * @internal
+     */
+    async attachLocationWithProgress(hypercertUri, location, onProgress) {
+        this.emitProgress(onProgress, { name: "attachLocation", status: "start" });
+        try {
+            const locationResult = await this.attachLocation(hypercertUri, location);
+            this.emitProgress(onProgress, {
+                name: "attachLocation",
+                status: "success",
+                data: { uri: locationResult.uri },
+            });
+            return locationResult.uri;
+        }
+        catch (error) {
+            this.emitProgress(onProgress, { name: "attachLocation", status: "error", error: error });
+            this.logger?.warn(`Failed to attach location: ${error instanceof Error ? error.message : "Unknown"}`);
+            throw error;
+        }
+    }
+    /**
+     * Creates contribution records with progress tracking.
+     *
+     * @param hypercertUri - URI of the hypercert
+     * @param contributions - Array of contribution data
+     * @param onProgress - Optional progress callback
+     * @returns Promise resolving to array of contribution URIs
+     * @internal
+     */
+    async createContributionsWithProgress(hypercertUri, contributions, onProgress) {
+        this.emitProgress(onProgress, { name: "createContributions", status: "start" });
+        try {
+            const contributionUris = [];
+            for (const contrib of contributions) {
+                const contribResult = await this.addContribution({
+                    hypercertUri,
+                    contributors: contrib.contributors,
+                    role: contrib.role,
+                    description: contrib.description,
+                });
+                contributionUris.push(contribResult.uri);
+            }
+            this.emitProgress(onProgress, {
+                name: "createContributions",
+                status: "success",
+                data: { count: contributionUris.length },
+            });
+            return contributionUris;
+        }
+        catch (error) {
+            this.emitProgress(onProgress, { name: "createContributions", status: "error", error: error });
+            this.logger?.warn(`Failed to create contributions: ${error instanceof Error ? error.message : "Unknown"}`);
+            throw error;
+        }
+    }
     /**
      * Creates a new hypercert with all related records.
      *
@@ -3294,142 +3323,31 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
         };
         try {
             // Step 1: Upload image if provided
-            let imageBlobRef;
-            if (params.image) {
-                this.emitProgress(params.onProgress, { name: "uploadImage", status: "start" });
-                try {
-                    const arrayBuffer = await params.image.arrayBuffer();
-                    const uint8Array = new Uint8Array(arrayBuffer);
-                    const uploadResult = await this.agent.com.atproto.repo.uploadBlob(uint8Array, {
-                        encoding: params.image.type || "image/jpeg",
-                    });
-                    if (uploadResult.success) {
-                        imageBlobRef = {
-                            $type: "blob",
-                            ref: { $link: uploadResult.data.blob.ref.toString() },
-                            mimeType: uploadResult.data.blob.mimeType,
-                            size: uploadResult.data.blob.size,
-                        };
-                    }
-                    this.emitProgress(params.onProgress, {
-                        name: "uploadImage",
-                        status: "success",
-                        data: { size: params.image.size },
-                    });
-                }
-                catch (error) {
-                    this.emitProgress(params.onProgress, { name: "uploadImage", status: "error", error: error });
-                    throw new NetworkError(`Failed to upload image: ${error instanceof Error ? error.message : "Unknown"}`, error);
-                }
-            }
+            const imageBlobRef = params.image ? await this.uploadImageBlob(params.image, params.onProgress) : undefined;
             // Step 2: Create rights record
-            this.emitProgress(params.onProgress, { name: "createRights", status: "start" });
-            const rightsRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.RIGHTS,
-                rightsName: params.rights.name,
-                rightsType: params.rights.type,
-                rightsDescription: params.rights.description,
-                createdAt,
-            };
-            const rightsValidation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.RIGHTS, rightsRecord);
-            if (!rightsValidation.valid) {
-                throw new ValidationError(`Invalid rights record: ${rightsValidation.error}`);
-            }
-            const rightsResult = await this.agent.com.atproto.repo.createRecord({
-                repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.RIGHTS,
-                record: rightsRecord,
-            });
-            if (!rightsResult.success) {
-                throw new NetworkError("Failed to create rights record");
-            }
-            result.rightsUri = rightsResult.data.uri;
-            result.rightsCid = rightsResult.data.cid;
-            this.emit("rightsCreated", { uri: result.rightsUri, cid: result.rightsCid });
-            this.emitProgress(params.onProgress, {
-                name: "createRights",
-                status: "success",
-                data: { uri: result.rightsUri },
-            });
+            const { uri: rightsUri, cid: rightsCid } = await this.createRightsRecord(params.rights, createdAt, params.onProgress);
+            result.rightsUri = rightsUri;
+            result.rightsCid = rightsCid;
             // Step 3: Create hypercert record
-            this.emitProgress(params.onProgress, { name: "createHypercert", status: "start" });
-            const hypercertRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.CLAIM,
-                title: params.title,
-                shortDescription: params.shortDescription,
-                description: params.description,
-                workScope: params.workScope,
-                workTimeFrameFrom: params.workTimeFrameFrom,
-                workTimeFrameTo: params.workTimeFrameTo,
-                rights: { uri: result.rightsUri, cid: result.rightsCid },
-                createdAt,
-            };
-            if (imageBlobRef) {
-                hypercertRecord.image = imageBlobRef;
-            }
-            if (params.evidence && params.evidence.length > 0) {
-                hypercertRecord.evidence = params.evidence;
-            }
-            const hypercertValidation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.CLAIM, hypercertRecord);
-            if (!hypercertValidation.valid) {
-                throw new ValidationError(`Invalid hypercert record: ${hypercertValidation.error}`);
-            }
-            const hypercertResult = await this.agent.com.atproto.repo.createRecord({
-                repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.CLAIM,
-                record: hypercertRecord,
-            });
-            if (!hypercertResult.success) {
-                throw new NetworkError("Failed to create hypercert record");
-            }
-            result.hypercertUri = hypercertResult.data.uri;
-            result.hypercertCid = hypercertResult.data.cid;
-            this.emit("recordCreated", { uri: result.hypercertUri, cid: result.hypercertCid });
-            this.emitProgress(params.onProgress, {
-                name: "createHypercert",
-                status: "success",
-                data: { uri: result.hypercertUri },
-            });
+            const { uri: hypercertUri, cid: hypercertCid } = await this.createHypercertRecord(params, rightsUri, rightsCid, imageBlobRef, createdAt, params.onProgress);
+            result.hypercertUri = hypercertUri;
+            result.hypercertCid = hypercertCid;
             // Step 4: Attach location if provided
             if (params.location) {
-                this.emitProgress(params.onProgress, { name: "attachLocation", status: "start" });
                 try {
-                    const locationResult = await this.attachLocation(result.hypercertUri, params.location);
-                    result.locationUri = locationResult.uri;
-                    this.emitProgress(params.onProgress, {
-                        name: "attachLocation",
-                        status: "success",
-                        data: { uri: result.locationUri },
-                    });
+                    result.locationUri = await this.attachLocationWithProgress(hypercertUri, params.location, params.onProgress);
                 }
-                catch (error) {
-                    this.emitProgress(params.onProgress, { name: "attachLocation", status: "error", error: error });
-                    this.logger?.warn(`Failed to attach location: ${error instanceof Error ? error.message : "Unknown"}`);
+                catch {
+                    // Error already logged and progress emitted
                 }
             }
             // Step 5: Create contributions if provided
             if (params.contributions && params.contributions.length > 0) {
-                this.emitProgress(params.onProgress, { name: "createContributions", status: "start" });
-                result.contributionUris = [];
                 try {
-                    for (const contrib of params.contributions) {
-                        const contribResult = await this.addContribution({
-                            hypercertUri: result.hypercertUri,
-                            contributors: contrib.contributors,
-                            role: contrib.role,
-                            description: contrib.description,
-                        });
-                        result.contributionUris.push(contribResult.uri);
-                    }
-                    this.emitProgress(params.onProgress, {
-                        name: "createContributions",
-                        status: "success",
-                        data: { count: result.contributionUris.length },
-                    });
+                    result.contributionUris = await this.createContributionsWithProgress(hypercertUri, params.contributions, params.onProgress);
                 }
-                catch (error) {
-                    this.emitProgress(params.onProgress, { name: "createContributions", status: "error", error: error });
-                    this.logger?.warn(`Failed to create contributions: ${error instanceof Error ? error.message : "Unknown"}`);
+                catch {
+                    // Error already logged and progress emitted
                 }
             }
             return result;
@@ -3531,9 +3449,9 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
                 // Preserve existing image
                 recordForUpdate.image = existingRecord.image;
             }
-            const validation = this.lexiconRegistry.validate(collection, recordForUpdate);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid hypercert record: ${validation.error}`);
+            const validation = lexicon.validate(recordForUpdate, collection, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid hypercert record: ${validation.error?.message}`);
             }
             const result = await this.agent.com.atproto.repo.putRecord({
                 repo: this.repoDid,
@@ -3582,10 +3500,10 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
             if (!result.success) {
                 throw new NetworkError("Failed to get hypercert");
             }
-            // Validate with lexicon registry (more lenient - doesn't require $type)
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.CLAIM, result.data.value);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid hypercert record format: ${validation.error}`);
+            // Validate with lexicon (more lenient - doesn't require $type)
+            const validation = lexicon.validate(result.data.value, HYPERCERT_COLLECTIONS.CLAIM, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid hypercert record format: ${validation.error?.message}`);
             }
             return {
                 uri: result.data.uri,
@@ -3621,7 +3539,7 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
         try {
             const result = await this.agent.com.atproto.repo.listRecords({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.CLAIM,
+                collection: HYPERCERT_COLLECTIONS.CLAIM,
                 limit: params?.limit,
                 cursor: params?.cursor,
             });
@@ -3759,7 +3677,7 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
             }
             // Build location record according to app.certified.location lexicon
             const locationRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.LOCATION,
+                $type: HYPERCERT_COLLECTIONS.LOCATION,
                 lpVersion: "1.0",
                 srs: location.srs,
                 locationType,
@@ -3768,13 +3686,13 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
                 name: location.name,
                 description: location.description,
             };
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.LOCATION, locationRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid location record: ${validation.error}`);
+            const validation = lexicon.validate(locationRecord, HYPERCERT_COLLECTIONS.LOCATION, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid location record: ${validation.error?.message}`);
             }
             const result = await this.agent.com.atproto.repo.createRecord({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.LOCATION,
+                collection: HYPERCERT_COLLECTIONS.LOCATION,
                 record: locationRecord,
             });
             if (!result.success) {
@@ -3853,7 +3771,7 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
         try {
             const createdAt = new Date().toISOString();
             const contributionRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.CONTRIBUTION,
+                $type: HYPERCERT_COLLECTIONS.CONTRIBUTION,
                 contributors: params.contributors,
                 role: params.role,
                 createdAt,
@@ -3864,13 +3782,13 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
                 const hypercert = await this.get(params.hypercertUri);
                 contributionRecord.hypercert = { uri: hypercert.uri, cid: hypercert.cid };
             }
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.CONTRIBUTION, contributionRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid contribution record: ${validation.error}`);
+            const validation = lexicon.validate(contributionRecord, HYPERCERT_COLLECTIONS.CONTRIBUTION, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid contribution record: ${validation.error?.message}`);
             }
             const result = await this.agent.com.atproto.repo.createRecord({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.CONTRIBUTION,
+                collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,
                 record: contributionRecord,
             });
             if (!result.success) {
@@ -3919,7 +3837,7 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
             const hypercert = await this.get(params.hypercertUri);
             const createdAt = new Date().toISOString();
             const measurementRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.MEASUREMENT,
+                $type: HYPERCERT_COLLECTIONS.MEASUREMENT,
                 hypercert: { uri: hypercert.uri, cid: hypercert.cid },
                 measurers: params.measurers,
                 metric: params.metric,
@@ -3928,13 +3846,13 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
                 measurementMethodURI: params.methodUri,
                 evidenceURI: params.evidenceUris,
             };
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.MEASUREMENT, measurementRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid measurement record: ${validation.error}`);
+            const validation = lexicon.validate(measurementRecord, HYPERCERT_COLLECTIONS.MEASUREMENT, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid measurement record: ${validation.error?.message}`);
             }
             const result = await this.agent.com.atproto.repo.createRecord({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.MEASUREMENT,
+                collection: HYPERCERT_COLLECTIONS.MEASUREMENT,
                 record: measurementRecord,
             });
             if (!result.success) {
@@ -3975,19 +3893,19 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
             const subject = await this.get(params.subjectUri);
             const createdAt = new Date().toISOString();
             const evaluationRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.EVALUATION,
+                $type: HYPERCERT_COLLECTIONS.EVALUATION,
                 subject: { uri: subject.uri, cid: subject.cid },
                 evaluators: params.evaluators,
                 summary: params.summary,
                 createdAt,
             };
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.EVALUATION, evaluationRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid evaluation record: ${validation.error}`);
+            const validation = lexicon.validate(evaluationRecord, HYPERCERT_COLLECTIONS.EVALUATION, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid evaluation record: ${validation.error?.message}`);
             }
             const result = await this.agent.com.atproto.repo.createRecord({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.EVALUATION,
+                collection: HYPERCERT_COLLECTIONS.EVALUATION,
                 record: evaluationRecord,
             });
             if (!result.success) {
@@ -4050,7 +3968,7 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
                 }
             }
             const collectionRecord = {
-                $type: lexicon.HYPERCERT_COLLECTIONS.COLLECTION,
+                $type: HYPERCERT_COLLECTIONS.COLLECTION,
                 title: params.title,
                 claims: params.claims.map((c) => ({ claim: { uri: c.uri, cid: c.cid }, weight: c.weight })),
                 createdAt,
@@ -4061,13 +3979,13 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
             if (coverPhotoRef) {
                 collectionRecord.coverPhoto = coverPhotoRef;
             }
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.COLLECTION, collectionRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid collection record: ${validation.error}`);
+            const validation = lexicon.validate(collectionRecord, HYPERCERT_COLLECTIONS.COLLECTION, "main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid collection record: ${validation.error?.message}`);
             }
             const result = await this.agent.com.atproto.repo.createRecord({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.COLLECTION,
+                collection: HYPERCERT_COLLECTIONS.COLLECTION,
                 record: collectionRecord,
             });
             if (!result.success) {
@@ -4113,9 +4031,9 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
                 throw new NetworkError("Failed to get collection");
             }
             // Validate with lexicon registry (more lenient - doesn't require $type)
-            const validation = this.lexiconRegistry.validate(lexicon.HYPERCERT_COLLECTIONS.COLLECTION, result.data.value);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid collection record format: ${validation.error}`);
+            const validation = lexicon.validate(result.data.value, HYPERCERT_COLLECTIONS.COLLECTION, "#main", false);
+            if (!validation.success) {
+                throw new ValidationError(`Invalid collection record format: ${validation.error?.message}`);
             }
             return {
                 uri: result.data.uri,
@@ -4148,7 +4066,7 @@ class HypercertOperationsImpl extends eventemitter3.EventEmitter {
         try {
             const result = await this.agent.com.atproto.repo.listRecords({
                 repo: this.repoDid,
-                collection: lexicon.HYPERCERT_COLLECTIONS.COLLECTION,
+                collection: HYPERCERT_COLLECTIONS.COLLECTION,
                 limit: params?.limit,
                 cursor: params?.cursor,
             });
@@ -4912,7 +4830,6 @@ class Repository {
      * @param session - Authenticated OAuth session
      * @param serverUrl - Base URL of the AT Protocol server
      * @param repoDid - DID of the repository to operate on
-     * @param lexiconRegistry - Registry for lexicon validation
      * @param isSDS - Whether this is a Shared Data Server
      * @param logger - Optional logger for debugging
      *
@@ -4922,20 +4839,16 @@ class Repository {
      *
      * @internal
      */
-    constructor(session, serverUrl, repoDid, lexiconRegistry, isSDS, logger) {
+    constructor(session, serverUrl, repoDid, isSDS, logger) {
         this.session = session;
         this.serverUrl = serverUrl;
         this.repoDid = repoDid;
-        this.lexiconRegistry = lexiconRegistry;
         this._isSDS = isSDS;
         this.logger = logger;
         // Create a ConfigurableAgent that routes requests to the specified server URL
         // This allows routing to PDS, SDS, or any custom server while maintaining
         // the OAuth session's authentication
         this.agent = new ConfigurableAgent(session, serverUrl);
-        this.lexiconRegistry.addToAgent(this.agent);
-        // Register hypercert lexicons
-        this.lexiconRegistry.registerMany(lexicon.HYPERCERT_LEXICONS);
     }
     /**
      * The DID (Decentralized Identifier) of this repository.
@@ -5006,7 +4919,7 @@ class Repository {
      * ```
      */
     repo(did) {
-        return new Repository(this.session, this.serverUrl, did, this.lexiconRegistry, this._isSDS, this.logger);
+        return new Repository(this.session, this.serverUrl, did, this._isSDS, this.logger);
     }
     /**
      * Low-level record operations for CRUD on any AT Protocol record type.
@@ -5039,7 +4952,7 @@ class Repository {
      */
     get records() {
         if (!this._records) {
-            this._records = new RecordOperationsImpl(this.agent, this.repoDid, this.lexiconRegistry);
+            this._records = new RecordOperationsImpl(this.agent, this.repoDid);
         }
         return this._records;
     }
@@ -5134,7 +5047,7 @@ class Repository {
      */
     get hypercerts() {
         if (!this._hypercerts) {
-            this._hypercerts = new HypercertOperationsImpl(this.agent, this.repoDid, this.serverUrl, this.lexiconRegistry, this.logger);
+            this._hypercerts = new HypercertOperationsImpl(this.agent, this.repoDid, this.serverUrl, this.logger);
         }
         return this._hypercerts;
     }
@@ -5430,8 +5343,6 @@ class ATProtoSDK {
         this.logger = config.logger;
         // Initialize OAuth client
         this.oauthClient = new OAuthClient(configWithDefaults);
-        // Initialize lexicon registry
-        this.lexiconRegistry = new LexiconRegistry();
         this.logger?.info("ATProto SDK initialized");
     }
     /**
@@ -5713,30 +5624,7 @@ class ATProtoSDK {
         }
         // Get repository DID (default to session DID)
         const repoDid = session.did || session.sub;
-        return new Repository(session, serverUrl, repoDid, this.lexiconRegistry, isSDS, this.logger);
-    }
-    /**
-     * Gets the lexicon registry for schema validation.
-     *
-     * The lexicon registry manages AT Protocol lexicon schemas used for
-     * validating record data. You can register custom lexicons to extend
-     * the SDK's capabilities.
-     *
-     * @returns The {@link LexiconRegistry} instance
-     *
-     * @example
-     * ```typescript
-     * const registry = sdk.getLexiconRegistry();
-     *
-     * // Register custom lexicons
-     * registry.register(myCustomLexicons);
-     *
-     * // Check if a lexicon is registered
-     * const hasLexicon = registry.has("org.example.myRecord");
-     * ```
-     */
-    getLexiconRegistry() {
-        return this.lexiconRegistry;
+        return new Repository(session, serverUrl, repoDid, isSDS, this.logger);
     }
     /**
      * The configured PDS (Personal Data Server) URL.
@@ -5892,6 +5780,18 @@ const CollaboratorSchema = zod.z.object({
     revokedAt: zod.z.string().optional(),
 });
 
+Object.defineProperty(exports, "AppCertifiedBadgeAward", {
+    enumerable: true,
+    get: function () { return lexicon.AppCertifiedBadgeAward; }
+});
+Object.defineProperty(exports, "AppCertifiedBadgeDefinition", {
+    enumerable: true,
+    get: function () { return lexicon.AppCertifiedBadgeDefinition; }
+});
+Object.defineProperty(exports, "AppCertifiedBadgeResponse", {
+    enumerable: true,
+    get: function () { return lexicon.AppCertifiedBadgeResponse; }
+});
 Object.defineProperty(exports, "AppCertifiedLocation", {
     enumerable: true,
     get: function () { return lexicon.AppCertifiedLocation; }
@@ -5900,17 +5800,29 @@ Object.defineProperty(exports, "ComAtprotoRepoStrongRef", {
     enumerable: true,
     get: function () { return lexicon.ComAtprotoRepoStrongRef; }
 });
-Object.defineProperty(exports, "HYPERCERT_COLLECTIONS", {
+Object.defineProperty(exports, "HYPERCERTS_NSIDS", {
+    enumerable: true,
+    get: function () { return lexicon.HYPERCERTS_NSIDS; }
+});
+Object.defineProperty(exports, "HYPERCERTS_NSIDS_BY_TYPE", {
+    enumerable: true,
+    get: function () { return lexicon.HYPERCERTS_NSIDS_BY_TYPE; }
+});
+Object.defineProperty(exports, "HYPERCERTS_SCHEMAS", {
+    enumerable: true,
+    get: function () { return lexicon.HYPERCERTS_SCHEMAS; }
+});
+Object.defineProperty(exports, "HYPERCERTS_SCHEMA_DICT", {
     enumerable: true,
-    get: function () { return lexicon.HYPERCERT_COLLECTIONS; }
+    get: function () { return lexicon.HYPERCERTS_SCHEMA_DICT; }
 });
-Object.defineProperty(exports, "HYPERCERT_LEXICONS", {
+Object.defineProperty(exports, "OrgHypercertsClaimActivity", {
     enumerable: true,
-    get: function () { return lexicon.HYPERCERT_LEXICONS; }
+    get: function () { return lexicon.OrgHypercertsClaimActivity; }
 });
-Object.defineProperty(exports, "OrgHypercertsClaim", {
+Object.defineProperty(exports, "OrgHypercertsClaimCollection", {
     enumerable: true,
-    get: function () { return lexicon.OrgHypercertsClaim; }
+    get: function () { return lexicon.OrgHypercertsClaimCollection; }
 });
 Object.defineProperty(exports, "OrgHypercertsClaimContribution", {
     enumerable: true,
@@ -5928,29 +5840,17 @@ Object.defineProperty(exports, "OrgHypercertsClaimMeasurement", {
     enumerable: true,
     get: function () { return lexicon.OrgHypercertsClaimMeasurement; }
 });
-Object.defineProperty(exports, "OrgHypercertsClaimRights", {
-    enumerable: true,
-    get: function () { return lexicon.OrgHypercertsClaimRights; }
-});
-Object.defineProperty(exports, "OrgHypercertsCollection", {
-    enumerable: true,
-    get: function () { return lexicon.OrgHypercertsCollection; }
-});
-Object.defineProperty(exports, "ids", {
-    enumerable: true,
-    get: function () { return lexicon.ids; }
-});
-Object.defineProperty(exports, "lexicons", {
+Object.defineProperty(exports, "OrgHypercertsClaimProject", {
     enumerable: true,
-    get: function () { return lexicon.lexicons; }
+    get: function () { return lexicon.OrgHypercertsClaimProject; }
 });
-Object.defineProperty(exports, "schemaDict", {
+Object.defineProperty(exports, "OrgHypercertsClaimRights", {
     enumerable: true,
-    get: function () { return lexicon.schemaDict; }
+    get: function () { return lexicon.OrgHypercertsClaimRights; }
 });
-Object.defineProperty(exports, "schemas", {
+Object.defineProperty(exports, "OrgHypercertsFundingReceipt", {
     enumerable: true,
-    get: function () { return lexicon.schemas; }
+    get: function () { return lexicon.OrgHypercertsFundingReceipt; }
 });
 Object.defineProperty(exports, "validate", {
     enumerable: true,
@@ -5968,12 +5868,13 @@ exports.BlobPermissionSchema = BlobPermissionSchema;
 exports.CollaboratorPermissionsSchema = CollaboratorPermissionsSchema;
 exports.CollaboratorSchema = CollaboratorSchema;
 exports.ConfigurableAgent = ConfigurableAgent;
+exports.HYPERCERT_COLLECTIONS = HYPERCERT_COLLECTIONS;
+exports.HYPERCERT_LEXICONS = HYPERCERT_LEXICONS;
 exports.IdentityAttrSchema = IdentityAttrSchema;
 exports.IdentityPermissionSchema = IdentityPermissionSchema;
 exports.InMemorySessionStore = InMemorySessionStore;
 exports.InMemoryStateStore = InMemoryStateStore;
 exports.IncludePermissionSchema = IncludePermissionSchema;
-exports.LexiconRegistry = LexiconRegistry;
 exports.MimeTypeSchema = MimeTypeSchema;
 exports.NetworkError = NetworkError;
 exports.NsidSchema = NsidSchema;