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

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import { JoseKey, NodeOAuthClient } from '@atproto/oauth-client-node';
 import { z } from 'zod';
-import { Lexicons } from '@atproto/lexicon';
-import { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS } from '@hypercerts-org/lexicon';
-export { AppCertifiedLocation, ComAtprotoRepoStrongRef, HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS, OrgHypercertsClaim, OrgHypercertsClaimContribution, OrgHypercertsClaimEvaluation, OrgHypercertsClaimEvidence, OrgHypercertsClaimMeasurement, OrgHypercertsClaimRights, OrgHypercertsCollection, ids, lexicons, schemaDict, schemas, validate } from '@hypercerts-org/lexicon';
 import { Agent } from '@atproto/api';
 import { EventEmitter } from 'eventemitter3';
+import { CERTIFIED_DEFS_LEXICON_JSON, LOCATION_LEXICON_JSON, STRONGREF_LEXICON_JSON, HYPERCERTS_DEFS_LEXICON_JSON, ACTIVITY_LEXICON_JSON, COLLECTION_LEXICON_JSON, CONTRIBUTION_LEXICON_JSON, EVALUATION_LEXICON_JSON, EVIDENCE_LEXICON_JSON, MEASUREMENT_LEXICON_JSON, RIGHTS_LEXICON_JSON, PROJECT_LEXICON_JSON, BADGE_AWARD_LEXICON_JSON, BADGE_DEFINITION_LEXICON_JSON, BADGE_RESPONSE_LEXICON_JSON, FUNDING_RECEIPT_LEXICON_JSON, FUNDING_RECEIPT_NSID, BADGE_RESPONSE_NSID, BADGE_DEFINITION_NSID, BADGE_AWARD_NSID, PROJECT_NSID, COLLECTION_NSID, EVIDENCE_NSID, EVALUATION_NSID, MEASUREMENT_NSID, CONTRIBUTION_NSID, LOCATION_NSID, RIGHTS_NSID, ACTIVITY_NSID, validate } from '@hypercerts-org/lexicon';
+export { AppCertifiedBadgeAward, AppCertifiedBadgeDefinition, AppCertifiedBadgeResponse, AppCertifiedLocation, ComAtprotoRepoStrongRef, HYPERCERTS_NSIDS, HYPERCERTS_NSIDS_BY_TYPE, HYPERCERTS_SCHEMAS, HYPERCERTS_SCHEMA_DICT, OrgHypercertsClaimActivity, OrgHypercertsClaimCollection, OrgHypercertsClaimContribution, OrgHypercertsClaimEvaluation, OrgHypercertsClaimEvidence, OrgHypercertsClaimMeasurement, OrgHypercertsClaimProject, OrgHypercertsClaimRights, OrgHypercertsFundingReceipt, validate } from '@hypercerts-org/lexicon';
+import '@atproto/lexicon';
 
 /**
  * Base error class for all SDK errors.
@@ -2003,303 +2003,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 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 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.
  *
@@ -2428,14 +2131,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.
@@ -2471,10 +2172,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,
@@ -2529,10 +2226,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,
@@ -3124,6 +2817,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 = [
+    CERTIFIED_DEFS_LEXICON_JSON,
+    LOCATION_LEXICON_JSON,
+    STRONGREF_LEXICON_JSON,
+    HYPERCERTS_DEFS_LEXICON_JSON,
+    ACTIVITY_LEXICON_JSON,
+    COLLECTION_LEXICON_JSON,
+    CONTRIBUTION_LEXICON_JSON,
+    EVALUATION_LEXICON_JSON,
+    EVIDENCE_LEXICON_JSON,
+    MEASUREMENT_LEXICON_JSON,
+    RIGHTS_LEXICON_JSON,
+    PROJECT_LEXICON_JSON,
+    BADGE_AWARD_LEXICON_JSON,
+    BADGE_DEFINITION_LEXICON_JSON,
+    BADGE_RESPONSE_LEXICON_JSON,
+    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: ACTIVITY_NSID,
+    /**
+     * Rights record collection.
+     */
+    RIGHTS: RIGHTS_NSID,
+    /**
+     * Location record collection (shared certified lexicon).
+     */
+    LOCATION: LOCATION_NSID,
+    /**
+     * Contribution record collection.
+     */
+    CONTRIBUTION: CONTRIBUTION_NSID,
+    /**
+     * Measurement record collection.
+     */
+    MEASUREMENT: MEASUREMENT_NSID,
+    /**
+     * Evaluation record collection.
+     */
+    EVALUATION: EVALUATION_NSID,
+    /**
+     * Evidence record collection.
+     */
+    EVIDENCE: EVIDENCE_NSID,
+    /**
+     * Collection record collection (groups of hypercerts).
+     */
+    COLLECTION: COLLECTION_NSID,
+    /**
+     * Project record collection.
+     */
+    PROJECT: PROJECT_NSID,
+    /**
+     * Badge award record collection.
+     */
+    BADGE_AWARD: BADGE_AWARD_NSID,
+    /**
+     * Badge definition record collection.
+     */
+    BADGE_DEFINITION: BADGE_DEFINITION_NSID,
+    /**
+     * Badge response record collection.
+     */
+    BADGE_RESPONSE: BADGE_RESPONSE_NSID,
+    /**
+     * Funding receipt record collection.
+     */
+    FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
+};
+
 /**
  * HypercertOperationsImpl - High-level hypercert operations.
  *
@@ -3187,17 +3022,15 @@ class HypercertOperationsImpl extends 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;
     }
     /**
@@ -3217,6 +3050,202 @@ class HypercertOperationsImpl extends 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 = 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 = 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.
      *
@@ -3293,142 +3322,31 @@ class HypercertOperationsImpl extends 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: HYPERCERT_COLLECTIONS.RIGHTS,
-                rightsName: params.rights.name,
-                rightsType: params.rights.type,
-                rightsDescription: params.rights.description,
-                createdAt,
-            };
-            const rightsValidation = this.lexiconRegistry.validate(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: 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: 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(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: 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;
@@ -3530,9 +3448,9 @@ class HypercertOperationsImpl extends 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 = 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,
@@ -3581,10 +3499,10 @@ class HypercertOperationsImpl extends 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(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 = 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,
@@ -3767,9 +3685,9 @@ class HypercertOperationsImpl extends EventEmitter {
                 name: location.name,
                 description: location.description,
             };
-            const validation = this.lexiconRegistry.validate(HYPERCERT_COLLECTIONS.LOCATION, locationRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid location record: ${validation.error}`);
+            const validation = 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,
@@ -3863,9 +3781,9 @@ class HypercertOperationsImpl extends EventEmitter {
                 const hypercert = await this.get(params.hypercertUri);
                 contributionRecord.hypercert = { uri: hypercert.uri, cid: hypercert.cid };
             }
-            const validation = this.lexiconRegistry.validate(HYPERCERT_COLLECTIONS.CONTRIBUTION, contributionRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid contribution record: ${validation.error}`);
+            const validation = 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,
@@ -3927,9 +3845,9 @@ class HypercertOperationsImpl extends EventEmitter {
                 measurementMethodURI: params.methodUri,
                 evidenceURI: params.evidenceUris,
             };
-            const validation = this.lexiconRegistry.validate(HYPERCERT_COLLECTIONS.MEASUREMENT, measurementRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid measurement record: ${validation.error}`);
+            const validation = 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,
@@ -3980,9 +3898,9 @@ class HypercertOperationsImpl extends EventEmitter {
                 summary: params.summary,
                 createdAt,
             };
-            const validation = this.lexiconRegistry.validate(HYPERCERT_COLLECTIONS.EVALUATION, evaluationRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid evaluation record: ${validation.error}`);
+            const validation = 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,
@@ -4060,9 +3978,9 @@ class HypercertOperationsImpl extends EventEmitter {
             if (coverPhotoRef) {
                 collectionRecord.coverPhoto = coverPhotoRef;
             }
-            const validation = this.lexiconRegistry.validate(HYPERCERT_COLLECTIONS.COLLECTION, collectionRecord);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid collection record: ${validation.error}`);
+            const validation = 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,
@@ -4112,9 +4030,9 @@ class HypercertOperationsImpl extends EventEmitter {
                 throw new NetworkError("Failed to get collection");
             }
             // Validate with lexicon registry (more lenient - doesn't require $type)
-            const validation = this.lexiconRegistry.validate(HYPERCERT_COLLECTIONS.COLLECTION, result.data.value);
-            if (!validation.valid) {
-                throw new ValidationError(`Invalid collection record format: ${validation.error}`);
+            const validation = 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,
@@ -4911,7 +4829,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
      *
@@ -4921,20 +4838,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(HYPERCERT_LEXICONS);
     }
     /**
      * The DID (Decentralized Identifier) of this repository.
@@ -5005,7 +4918,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.
@@ -5038,7 +4951,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;
     }
@@ -5133,7 +5046,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;
     }
@@ -5429,8 +5342,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");
     }
     /**
@@ -5712,30 +5623,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.
@@ -5891,5 +5779,5 @@ const CollaboratorSchema = z.object({
     revokedAt: z.string().optional(),
 });
 
-export { ATPROTO_SCOPE, ATProtoSDK, ATProtoSDKConfigSchema, ATProtoSDKError, AccountActionSchema, AccountAttrSchema, AccountPermissionSchema, AuthenticationError, BlobPermissionSchema, CollaboratorPermissionsSchema, CollaboratorSchema, ConfigurableAgent, IdentityAttrSchema, IdentityPermissionSchema, InMemorySessionStore, InMemoryStateStore, IncludePermissionSchema, LexiconRegistry, MimeTypeSchema, NetworkError, NsidSchema, OAuthConfigSchema, OrganizationSchema, PermissionBuilder, PermissionSchema, RepoActionSchema, RepoPermissionSchema, Repository, RpcPermissionSchema, SDSRequiredError, ScopePresets, ServerConfigSchema, SessionExpiredError, TRANSITION_SCOPES, TimeoutConfigSchema, TransitionScopeSchema, ValidationError, buildScope, createATProtoSDK, hasAllPermissions, hasAnyPermission, hasPermission, mergeScopes, parseScope, removePermissions, validateScope };
+export { ATPROTO_SCOPE, ATProtoSDK, ATProtoSDKConfigSchema, ATProtoSDKError, AccountActionSchema, AccountAttrSchema, AccountPermissionSchema, AuthenticationError, BlobPermissionSchema, CollaboratorPermissionsSchema, CollaboratorSchema, ConfigurableAgent, HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS, IdentityAttrSchema, IdentityPermissionSchema, InMemorySessionStore, InMemoryStateStore, IncludePermissionSchema, MimeTypeSchema, NetworkError, NsidSchema, OAuthConfigSchema, OrganizationSchema, PermissionBuilder, PermissionSchema, RepoActionSchema, RepoPermissionSchema, Repository, RpcPermissionSchema, SDSRequiredError, ScopePresets, ServerConfigSchema, SessionExpiredError, TRANSITION_SCOPES, TimeoutConfigSchema, TransitionScopeSchema, ValidationError, buildScope, createATProtoSDK, hasAllPermissions, hasAnyPermission, hasPermission, mergeScopes, parseScope, removePermissions, validateScope };
 //# sourceMappingURL=index.mjs.map