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

package/dist/lexicons.mjs

@@ -1,410 +1,146 @@
-import { Lexicons } from '@atproto/lexicon';
-export { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS } from '@hypercerts-org/lexicon';
+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 } from '@hypercerts-org/lexicon';
 
 /**
- * Base error class for all SDK errors.
+ * Lexicons entrypoint - Lexicon definitions and registry.
  *
- * All errors thrown by the Hypercerts SDK extend this class, making it easy
- * to catch and handle SDK-specific errors.
+ * This sub-entrypoint exports the lexicon registry and hypercert
+ * lexicon constants for working with AT Protocol record schemas.
  *
- * @example Catching all SDK errors
- * ```typescript
- * try {
- *   await sdk.authorize("user.bsky.social");
- * } catch (error) {
- *   if (error instanceof ATProtoSDKError) {
- *     console.error(`SDK Error [${error.code}]: ${error.message}`);
- *     console.error(`HTTP Status: ${error.status}`);
- *   }
- * }
- * ```
+ * @remarks
+ * Import from `@hypercerts-org/sdk/lexicons`:
  *
- * @example Checking error codes
  * ```typescript
- * try {
- *   await repo.records.get(collection, rkey);
- * } catch (error) {
- *   if (error instanceof ATProtoSDKError) {
- *     switch (error.code) {
- *       case "AUTHENTICATION_ERROR":
- *         // Redirect to login
- *         break;
- *       case "VALIDATION_ERROR":
- *         // Show form errors
- *         break;
- *       case "NETWORK_ERROR":
- *         // Retry or show offline message
- *         break;
- *     }
- *   }
- * }
+ * import {
+ *   LexiconRegistry,
+ *   HYPERCERT_LEXICONS,
+ *   HYPERCERT_COLLECTIONS,
+ * } from "@hypercerts-org/sdk/lexicons";
  * ```
- */
-class ATProtoSDKError extends Error {
-    /**
-     * Creates a new SDK error.
-     *
-     * @param message - Human-readable error description
-     * @param code - Machine-readable error code for programmatic handling
-     * @param status - HTTP status code associated with this error type
-     * @param cause - The underlying error that caused this error, if any
-     */
-    constructor(message, code, status, cause) {
-        super(message);
-        this.code = code;
-        this.status = status;
-        this.cause = cause;
-        this.name = "ATProtoSDKError";
-        Error.captureStackTrace?.(this, this.constructor);
-    }
-}
-/**
- * Error thrown when input validation fails.
  *
- * This error indicates that provided data doesn't meet the required format
- * or constraints. Common causes:
- * - Missing required fields
- * - Invalid URL formats
- * - Invalid DID format
- * - Schema validation failures for records
- * - Invalid configuration values
- *
- * @example
- * ```typescript
- * try {
- *   await sdk.authorize("");  // Empty identifier
- * } catch (error) {
- *   if (error instanceof ValidationError) {
- *     console.error("Invalid input:", error.message);
- *     // Show validation error to user
- *   }
- * }
- * ```
+ * **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 With Zod validation cause
+ * @example Using collection constants
  * ```typescript
- * try {
- *   await repo.records.create(collection, record);
- * } catch (error) {
- *   if (error instanceof ValidationError && error.cause) {
- *     // error.cause may be a ZodError with detailed field errors
- *     const zodError = error.cause as ZodError;
- *     zodError.errors.forEach(e => {
- *       console.error(`Field ${e.path.join(".")}: ${e.message}`);
- *     });
- *   }
- * }
- * ```
- */
-class ValidationError extends ATProtoSDKError {
-    /**
-     * Creates a validation error.
-     *
-     * @param message - Description of what validation failed
-     * @param cause - The underlying validation error (e.g., ZodError)
-     */
-    constructor(message, cause) {
-        super(message, "VALIDATION_ERROR", 400, cause);
-        this.name = "ValidationError";
-    }
-}
-
-/**
- * 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:
+ * import { HYPERCERT_COLLECTIONS } from "@hypercerts-org/sdk/lexicons";
  *
- * - 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.
+ * // List hypercerts using the correct collection name
+ * const records = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.RECORD,
+ * });
  *
- * **Lexicon IDs** follow the NSID (Namespaced Identifier) format:
- * `{authority}.{name}` (e.g., `org.hypercerts.hypercert`)
+ * // List contributions
+ * const contributions = await repo.records.list({
+ *   collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,
+ * });
+ * ```
  *
- * @example Registering custom lexicons
+ * @example Custom lexicon registration
  * ```typescript
+ * import { LexiconRegistry } from "@hypercerts-org/sdk/lexicons";
+ *
  * const registry = sdk.getLexiconRegistry();
  *
- * // Register a single lexicon
+ * // Register custom 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(),
+ *   id: "org.myapp.customRecord",
+ *   defs: { ... },
  * });
  *
+ * // Validate a record
+ * const result = registry.validate("org.myapp.customRecord", record);
  * if (!result.valid) {
- *   console.error(`Validation failed: ${result.error}`);
+ *   console.error(result.error);
  * }
  * ```
  *
- * @see https://atproto.com/specs/lexicon for the Lexicon specification
+ * @packageDocumentation
+ */
+/**
+ * All hypercert-related lexicons for registration with AT Protocol Agent.
+ * This array contains all lexicon documents from the published package.
  */
-class LexiconRegistry {
+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,
     /**
-     * Creates a new LexiconRegistry.
-     *
-     * The registry starts empty. Use {@link register} or {@link registerMany}
-     * to add lexicons.
+     * Evaluation record collection.
      */
-    constructor() {
-        /** Map of lexicon ID to lexicon document */
-        this.lexicons = new Map();
-        this.lexiconsCollection = new Lexicons();
-    }
+    EVALUATION: EVALUATION_NSID,
     /**
-     * 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" },
-     *         },
-     *       },
-     *     },
-     *   },
-     * });
-     * ```
+     * Evidence record collection.
      */
-    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);
-    }
+    EVIDENCE: EVIDENCE_NSID,
     /**
-     * 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);
-     * ```
+     * Collection record collection (groups of hypercerts).
      */
-    registerMany(lexicons) {
-        for (const lexicon of lexicons) {
-            this.register(lexicon);
-        }
-    }
+    COLLECTION: COLLECTION_NSID,
     /**
-     * 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}`);
-     * }
-     * ```
+     * Project record collection.
      */
-    get(id) {
-        return this.lexicons.get(id);
-    }
+    PROJECT: PROJECT_NSID,
     /**
-     * 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}`);
-     * }
-     * ```
+     * Badge award record collection.
      */
-    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,
-            };
-        }
-    }
+    BADGE_AWARD: BADGE_AWARD_NSID,
     /**
-     * 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
+     * Badge definition record collection.
      */
-    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);
-        }
-    }
+    BADGE_DEFINITION: BADGE_DEFINITION_NSID,
     /**
-     * Gets all registered lexicon IDs.
-     *
-     * @returns Array of lexicon NSIDs
-     *
-     * @example
-     * ```typescript
-     * const ids = registry.getRegisteredIds();
-     * console.log(`Registered lexicons: ${ids.join(", ")}`);
-     * ```
+     * Badge response record collection.
      */
-    getRegisteredIds() {
-        return Array.from(this.lexicons.keys());
-    }
+    BADGE_RESPONSE: BADGE_RESPONSE_NSID,
     /**
-     * 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
-     * }
-     * ```
+     * Funding receipt record collection.
      */
-    has(id) {
-        return this.lexicons.has(id);
-    }
-}
+    FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,
+};
 
-export { LexiconRegistry };
+export { HYPERCERT_COLLECTIONS, HYPERCERT_LEXICONS };
 //# sourceMappingURL=lexicons.mjs.map

package/dist/lexicons.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"lexicons.mjs","sources":["../src/core/errors.ts","../src/repository/LexiconRegistry.ts"],"sourcesContent":["/**\n * Base error class for all SDK errors.\n *\n * All errors thrown by the Hypercerts SDK extend this class, making it easy\n * to catch and handle SDK-specific errors.\n *\n * @example Catching all SDK errors\n * ```typescript\n * try {\n *   await sdk.authorize(\"user.bsky.social\");\n * } catch (error) {\n *   if (error instanceof ATProtoSDKError) {\n *     console.error(`SDK Error [${error.code}]: ${error.message}`);\n *     console.error(`HTTP Status: ${error.status}`);\n *   }\n * }\n * ```\n *\n * @example Checking error codes\n * ```typescript\n * try {\n *   await repo.records.get(collection, rkey);\n * } catch (error) {\n *   if (error instanceof ATProtoSDKError) {\n *     switch (error.code) {\n *       case \"AUTHENTICATION_ERROR\":\n *         // Redirect to login\n *         break;\n *       case \"VALIDATION_ERROR\":\n *         // Show form errors\n *         break;\n *       case \"NETWORK_ERROR\":\n *         // Retry or show offline message\n *         break;\n *     }\n *   }\n * }\n * ```\n */\nexport class ATProtoSDKError extends Error {\n  /**\n   * Creates a new SDK error.\n   *\n   * @param message - Human-readable error description\n   * @param code - Machine-readable error code for programmatic handling\n   * @param status - HTTP status code associated with this error type\n   * @param cause - The underlying error that caused this error, if any\n   */\n  constructor(\n    message: string,\n    public code: string,\n    public status?: number,\n    public cause?: unknown,\n  ) {\n    super(message);\n    this.name = \"ATProtoSDKError\";\n    Error.captureStackTrace?.(this, this.constructor);\n  }\n}\n\n/**\n * Error thrown when authentication fails.\n *\n * This error indicates problems with the OAuth flow, invalid credentials,\n * or failed token exchanges. Common causes:\n * - Invalid authorization code\n * - Expired or invalid state parameter\n * - Revoked or invalid tokens\n * - User denied authorization\n *\n * @example\n * ```typescript\n * try {\n *   const session = await sdk.callback(params);\n * } catch (error) {\n *   if (error instanceof AuthenticationError) {\n *     // Clear any stored state and redirect to login\n *     console.error(\"Authentication failed:\", error.message);\n *   }\n * }\n * ```\n */\nexport class AuthenticationError extends ATProtoSDKError {\n  /**\n   * Creates an authentication error.\n   *\n   * @param message - Description of what went wrong during authentication\n   * @param cause - The underlying error (e.g., from the OAuth client)\n   */\n  constructor(message: string, cause?: unknown) {\n    super(message, \"AUTHENTICATION_ERROR\", 401, cause);\n    this.name = \"AuthenticationError\";\n  }\n}\n\n/**\n * Error thrown when a session has expired and cannot be refreshed.\n *\n * This typically occurs when:\n * - The refresh token has expired (usually after extended inactivity)\n * - The user has revoked access to your application\n * - The PDS has invalidated all sessions for the user\n *\n * When this error occurs, the user must re-authenticate.\n *\n * @example\n * ```typescript\n * try {\n *   const session = await sdk.restoreSession(did);\n * } catch (error) {\n *   if (error instanceof SessionExpiredError) {\n *     // Clear stored session and prompt user to log in again\n *     localStorage.removeItem(\"userDid\");\n *     window.location.href = \"/login\";\n *   }\n * }\n * ```\n */\nexport class SessionExpiredError extends ATProtoSDKError {\n  /**\n   * Creates a session expired error.\n   *\n   * @param message - Description of why the session expired\n   * @param cause - The underlying error from the token refresh attempt\n   */\n  constructor(message: string = \"Session expired\", cause?: unknown) {\n    super(message, \"SESSION_EXPIRED\", 401, cause);\n    this.name = \"SessionExpiredError\";\n  }\n}\n\n/**\n * Error thrown when input validation fails.\n *\n * This error indicates that provided data doesn't meet the required format\n * or constraints. Common causes:\n * - Missing required fields\n * - Invalid URL formats\n * - Invalid DID format\n * - Schema validation failures for records\n * - Invalid configuration values\n *\n * @example\n * ```typescript\n * try {\n *   await sdk.authorize(\"\");  // Empty identifier\n * } catch (error) {\n *   if (error instanceof ValidationError) {\n *     console.error(\"Invalid input:\", error.message);\n *     // Show validation error to user\n *   }\n * }\n * ```\n *\n * @example With Zod validation cause\n * ```typescript\n * try {\n *   await repo.records.create(collection, record);\n * } catch (error) {\n *   if (error instanceof ValidationError && error.cause) {\n *     // error.cause may be a ZodError with detailed field errors\n *     const zodError = error.cause as ZodError;\n *     zodError.errors.forEach(e => {\n *       console.error(`Field ${e.path.join(\".\")}: ${e.message}`);\n *     });\n *   }\n * }\n * ```\n */\nexport class ValidationError extends ATProtoSDKError {\n  /**\n   * Creates a validation error.\n   *\n   * @param message - Description of what validation failed\n   * @param cause - The underlying validation error (e.g., ZodError)\n   */\n  constructor(message: string, cause?: unknown) {\n    super(message, \"VALIDATION_ERROR\", 400, cause);\n    this.name = \"ValidationError\";\n  }\n}\n\n/**\n * Error thrown when a network request fails.\n *\n * This error indicates connectivity issues or server unavailability.\n * Common causes:\n * - No internet connection\n * - DNS resolution failure\n * - Server timeout\n * - Server returned 5xx error\n * - TLS/SSL errors\n *\n * These errors are typically transient and may succeed on retry.\n *\n * @example\n * ```typescript\n * try {\n *   await repo.records.list(collection);\n * } catch (error) {\n *   if (error instanceof NetworkError) {\n *     // Implement retry logic or show offline indicator\n *     console.error(\"Network error:\", error.message);\n *     await retryWithBackoff(() => repo.records.list(collection));\n *   }\n * }\n * ```\n */\nexport class NetworkError extends ATProtoSDKError {\n  /**\n   * Creates a network error.\n   *\n   * @param message - Description of the network failure\n   * @param cause - The underlying error (e.g., fetch error, timeout)\n   */\n  constructor(message: string, cause?: unknown) {\n    super(message, \"NETWORK_ERROR\", 503, cause);\n    this.name = \"NetworkError\";\n  }\n}\n\n/**\n * Error thrown when an SDS-only operation is attempted on a PDS.\n *\n * Certain operations are only available on Shared Data Servers (SDS),\n * such as collaborator management and organization operations.\n * This error is thrown when these operations are attempted on a\n * Personal Data Server (PDS).\n *\n * @example\n * ```typescript\n * const pdsRepo = sdk.repository(session);  // Default is PDS\n *\n * try {\n *   // This will throw SDSRequiredError\n *   await pdsRepo.collaborators.list();\n * } catch (error) {\n *   if (error instanceof SDSRequiredError) {\n *     // Switch to SDS for this operation\n *     const sdsRepo = sdk.repository(session, { server: \"sds\" });\n *     const collaborators = await sdsRepo.collaborators.list();\n *   }\n * }\n * ```\n */\nexport class SDSRequiredError extends ATProtoSDKError {\n  /**\n   * Creates an SDS required error.\n   *\n   * @param message - Description of which operation requires SDS\n   * @param cause - Any underlying error\n   */\n  constructor(message: string = \"This operation requires a Shared Data Server (SDS)\", cause?: unknown) {\n    super(message, \"SDS_REQUIRED\", 400, cause);\n    this.name = \"SDSRequiredError\";\n  }\n}\n","import type { Agent } from \"@atproto/api\";\nimport type { LexiconDoc } from \"@atproto/lexicon\";\nimport { Lexicons } from \"@atproto/lexicon\";\nimport { ValidationError } from \"../core/errors.js\";\n\n/**\n * Result of validating a record against a lexicon schema.\n */\nexport interface ValidationResult {\n  /**\n   * Whether the record is valid according to the lexicon schema.\n   */\n  valid: boolean;\n\n  /**\n   * Error message if validation failed.\n   *\n   * Only present when `valid` is `false`.\n   */\n  error?: string;\n}\n\n/**\n * Registry for managing and validating AT Protocol lexicon schemas.\n *\n * Lexicons are schema definitions that describe the structure of records\n * in the AT Protocol. This registry allows you to:\n *\n * - Register custom lexicons for your application's record types\n * - Validate records against their lexicon schemas\n * - Extend the AT Protocol Agent with custom lexicon support\n *\n * @remarks\n * The SDK automatically registers hypercert lexicons when creating a Repository.\n * You only need to use this class directly if you're working with custom\n * record types.\n *\n * **Lexicon IDs** follow the NSID (Namespaced Identifier) format:\n * `{authority}.{name}` (e.g., `org.hypercerts.hypercert`)\n *\n * @example Registering custom lexicons\n * ```typescript\n * const registry = sdk.getLexiconRegistry();\n *\n * // Register a single lexicon\n * registry.register({\n *   lexicon: 1,\n *   id: \"org.example.myRecord\",\n *   defs: {\n *     main: {\n *       type: \"record\",\n *       key: \"tid\",\n *       record: {\n *         type: \"object\",\n *         required: [\"title\", \"createdAt\"],\n *         properties: {\n *           title: { type: \"string\" },\n *           description: { type: \"string\" },\n *           createdAt: { type: \"string\", format: \"datetime\" },\n *         },\n *       },\n *     },\n *   },\n * });\n *\n * // Register multiple lexicons at once\n * registry.registerMany([lexicon1, lexicon2, lexicon3]);\n * ```\n *\n * @example Validating records\n * ```typescript\n * const result = registry.validate(\"org.example.myRecord\", {\n *   title: \"Test\",\n *   createdAt: new Date().toISOString(),\n * });\n *\n * if (!result.valid) {\n *   console.error(`Validation failed: ${result.error}`);\n * }\n * ```\n *\n * @see https://atproto.com/specs/lexicon for the Lexicon specification\n */\nexport class LexiconRegistry {\n  /** Map of lexicon ID to lexicon document */\n  private lexicons = new Map<string, LexiconDoc>();\n\n  /** Lexicons collection for validation */\n  private lexiconsCollection: Lexicons;\n\n  /**\n   * Creates a new LexiconRegistry.\n   *\n   * The registry starts empty. Use {@link register} or {@link registerMany}\n   * to add lexicons.\n   */\n  constructor() {\n    this.lexiconsCollection = new Lexicons();\n  }\n\n  /**\n   * Registers a single lexicon schema.\n   *\n   * @param lexicon - The lexicon document to register\n   * @throws {@link ValidationError} if the lexicon doesn't have an `id` field\n   *\n   * @remarks\n   * If a lexicon with the same ID is already registered, it will be\n   * replaced with the new definition. This is useful for testing but\n   * should generally be avoided in production.\n   *\n   * @example\n   * ```typescript\n   * registry.register({\n   *   lexicon: 1,\n   *   id: \"org.example.post\",\n   *   defs: {\n   *     main: {\n   *       type: \"record\",\n   *       key: \"tid\",\n   *       record: {\n   *         type: \"object\",\n   *         required: [\"text\", \"createdAt\"],\n   *         properties: {\n   *           text: { type: \"string\", maxLength: 300 },\n   *           createdAt: { type: \"string\", format: \"datetime\" },\n   *         },\n   *       },\n   *     },\n   *   },\n   * });\n   * ```\n   */\n  register(lexicon: LexiconDoc): void {\n    if (!lexicon.id) {\n      throw new ValidationError(\"Lexicon must have an 'id' field\");\n    }\n\n    // Remove existing lexicon if present (to allow overwriting)\n    if (this.lexicons.has(lexicon.id)) {\n      // Lexicons collection doesn't support removal, so we create a new one\n      // This is a limitation - in practice, lexicons shouldn't be overwritten\n      // But we allow it for testing and flexibility\n      const existingLexicon = this.lexicons.get(lexicon.id);\n      if (existingLexicon) {\n        // Try to remove from collection (may fail if not supported)\n        try {\n          // eslint-disable-next-line @typescript-eslint/no-explicit-any\n          (this.lexiconsCollection as any).remove?.(lexicon.id);\n        } catch {\n          // If removal fails, create a new collection\n          this.lexiconsCollection = new Lexicons();\n          // Re-register all other lexicons\n          for (const [id, lex] of this.lexicons.entries()) {\n            if (id !== lexicon.id) {\n              this.lexiconsCollection.add(lex);\n            }\n          }\n        }\n      }\n    }\n\n    this.lexicons.set(lexicon.id, lexicon);\n    this.lexiconsCollection.add(lexicon);\n  }\n\n  /**\n   * Registers multiple lexicons at once.\n   *\n   * @param lexicons - Array of lexicon documents to register\n   *\n   * @example\n   * ```typescript\n   * import { HYPERCERT_LEXICONS } from \"@hypercerts-org/sdk/lexicons\";\n   *\n   * registry.registerMany(HYPERCERT_LEXICONS);\n   * ```\n   */\n  registerMany(lexicons: LexiconDoc[]): void {\n    for (const lexicon of lexicons) {\n      this.register(lexicon);\n    }\n  }\n\n  /**\n   * Gets a lexicon document by ID.\n   *\n   * @param id - The lexicon NSID (e.g., \"org.hypercerts.hypercert\")\n   * @returns The lexicon document, or `undefined` if not registered\n   *\n   * @example\n   * ```typescript\n   * const lexicon = registry.get(\"org.hypercerts.hypercert\");\n   * if (lexicon) {\n   *   console.log(`Found lexicon: ${lexicon.id}`);\n   * }\n   * ```\n   */\n  get(id: string): LexiconDoc | undefined {\n    return this.lexicons.get(id);\n  }\n\n  /**\n   * Validates a record against a collection's lexicon schema.\n   *\n   * @param collection - The collection NSID (same as lexicon ID)\n   * @param record - The record data to validate\n   * @returns Validation result with `valid` boolean and optional `error` message\n   *\n   * @remarks\n   * - If no lexicon is registered for the collection, validation passes\n   *   (we can't validate against unknown schemas)\n   * - Validation checks required fields and type constraints defined\n   *   in the lexicon schema\n   *\n   * @example\n   * ```typescript\n   * const result = registry.validate(\"org.hypercerts.hypercert\", {\n   *   title: \"My Hypercert\",\n   *   description: \"Description...\",\n   *   // ... other fields\n   * });\n   *\n   * if (!result.valid) {\n   *   throw new Error(`Invalid record: ${result.error}`);\n   * }\n   * ```\n   */\n  validate(collection: string, record: unknown): ValidationResult {\n    // Check if we have a lexicon registered for this collection\n    // Collection format is typically \"namespace.collection\" (e.g., \"app.bsky.feed.post\")\n    // Lexicon ID format is the same\n    const lexiconId = collection;\n    const lexicon = this.lexicons.get(lexiconId);\n    if (!lexicon) {\n      // No lexicon registered - validation passes (can't validate unknown schemas)\n      return { valid: true };\n    }\n\n    // Check required fields if the lexicon defines them\n    const recordDef = lexicon.defs?.record;\n    if (recordDef && typeof recordDef === \"object\" && \"record\" in recordDef) {\n      const recordSchema = recordDef.record;\n      if (typeof recordSchema === \"object\" && \"required\" in recordSchema && Array.isArray(recordSchema.required)) {\n        const recordObj = record as Record<string, unknown>;\n        for (const requiredField of recordSchema.required) {\n          if (typeof requiredField === \"string\" && !(requiredField in recordObj)) {\n            return {\n              valid: false,\n              error: `Missing required field: ${requiredField}`,\n            };\n          }\n        }\n      }\n    }\n\n    try {\n      this.lexiconsCollection.assertValidRecord(collection, record);\n      return { valid: true };\n    } catch (error) {\n      // If error indicates lexicon not found, treat as validation pass\n      // (the lexicon might exist in Agent's collection but not ours)\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      if (errorMessage.includes(\"not found\") || errorMessage.includes(\"Lexicon not found\")) {\n        return { valid: true };\n      }\n      return {\n        valid: false,\n        error: errorMessage,\n      };\n    }\n  }\n\n  /**\n   * Adds all registered lexicons to an AT Protocol Agent instance.\n   *\n   * This allows the Agent to understand custom lexicon types when making\n   * API requests.\n   *\n   * @param agent - The Agent instance to extend\n   *\n   * @remarks\n   * This is called automatically when creating a Repository. You typically\n   * don't need to call this directly unless you're using the Agent\n   * independently.\n   *\n   * @internal\n   */\n  addToAgent(agent: Agent): void {\n    // Access the internal lexicons collection and merge our lexicons\n    // The Agent's lex property is a Lexicons instance\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const agentLex = (agent as any).lex as Lexicons;\n\n    // Add each registered lexicon to the agent\n    for (const lexicon of this.lexicons.values()) {\n      agentLex.add(lexicon);\n    }\n  }\n\n  /**\n   * Gets all registered lexicon IDs.\n   *\n   * @returns Array of lexicon NSIDs\n   *\n   * @example\n   * ```typescript\n   * const ids = registry.getRegisteredIds();\n   * console.log(`Registered lexicons: ${ids.join(\", \")}`);\n   * ```\n   */\n  getRegisteredIds(): string[] {\n    return Array.from(this.lexicons.keys());\n  }\n\n  /**\n   * Checks if a lexicon is registered.\n   *\n   * @param id - The lexicon NSID to check\n   * @returns `true` if the lexicon is registered\n   *\n   * @example\n   * ```typescript\n   * if (registry.has(\"org.hypercerts.hypercert\")) {\n   *   // Hypercert lexicon is available\n   * }\n   * ```\n   */\n  has(id: string): boolean {\n    return this.lexicons.has(id);\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"lexicons.mjs","sources":["../src/lexicons.ts"],"sourcesContent":["/**\n * Lexicons entrypoint - Lexicon definitions and registry.\n *\n * This sub-entrypoint exports the lexicon registry and hypercert\n * lexicon constants for working with AT Protocol record schemas.\n *\n * @remarks\n * Import from `@hypercerts-org/sdk/lexicons`:\n *\n * ```typescript\n * import {\n *   LexiconRegistry,\n *   HYPERCERT_LEXICONS,\n *   HYPERCERT_COLLECTIONS,\n * } from \"@hypercerts-org/sdk/lexicons\";\n * ```\n *\n * **Exports**:\n * - {@link LexiconRegistry} - Registry for managing and validating lexicons\n * - {@link HYPERCERT_LEXICONS} - Array of all hypercert lexicon documents\n * - {@link HYPERCERT_COLLECTIONS} - Constants for collection NSIDs\n *\n * @example Using collection constants\n * ```typescript\n * import { HYPERCERT_COLLECTIONS } from \"@hypercerts-org/sdk/lexicons\";\n *\n * // List hypercerts using the correct collection name\n * const records = await repo.records.list({\n *   collection: HYPERCERT_COLLECTIONS.RECORD,\n * });\n *\n * // List contributions\n * const contributions = await repo.records.list({\n *   collection: HYPERCERT_COLLECTIONS.CONTRIBUTION,\n * });\n * ```\n *\n * @example Custom lexicon registration\n * ```typescript\n * import { LexiconRegistry } from \"@hypercerts-org/sdk/lexicons\";\n *\n * const registry = sdk.getLexiconRegistry();\n *\n * // Register custom lexicon\n * registry.register({\n *   lexicon: 1,\n *   id: \"org.myapp.customRecord\",\n *   defs: { ... },\n * });\n *\n * // Validate a record\n * const result = registry.validate(\"org.myapp.customRecord\", record);\n * if (!result.valid) {\n *   console.error(result.error);\n * }\n * ```\n *\n * @packageDocumentation\n */\n\n// Import lexicon JSON files and constants from the published package\nimport type { LexiconDoc } from \"@atproto/lexicon\";\nimport {\n  CERTIFIED_DEFS_LEXICON_JSON,\n  LOCATION_LEXICON_JSON,\n  STRONGREF_LEXICON_JSON,\n  HYPERCERTS_DEFS_LEXICON_JSON,\n  ACTIVITY_LEXICON_JSON,\n  COLLECTION_LEXICON_JSON,\n  CONTRIBUTION_LEXICON_JSON,\n  EVALUATION_LEXICON_JSON,\n  EVIDENCE_LEXICON_JSON,\n  MEASUREMENT_LEXICON_JSON,\n  RIGHTS_LEXICON_JSON,\n  PROJECT_LEXICON_JSON,\n  BADGE_AWARD_LEXICON_JSON,\n  BADGE_DEFINITION_LEXICON_JSON,\n  BADGE_RESPONSE_LEXICON_JSON,\n  FUNDING_RECEIPT_LEXICON_JSON,\n  // NSID constants\n  ACTIVITY_NSID,\n  RIGHTS_NSID,\n  LOCATION_NSID,\n  CONTRIBUTION_NSID,\n  MEASUREMENT_NSID,\n  EVALUATION_NSID,\n  EVIDENCE_NSID,\n  COLLECTION_NSID,\n  PROJECT_NSID,\n  BADGE_AWARD_NSID,\n  BADGE_DEFINITION_NSID,\n  BADGE_RESPONSE_NSID,\n  FUNDING_RECEIPT_NSID,\n} from \"@hypercerts-org/lexicon\";\n\n/**\n * All hypercert-related lexicons for registration with AT Protocol Agent.\n * This array contains all lexicon documents from the published package.\n */\nexport const HYPERCERT_LEXICONS: LexiconDoc[] = [\n  CERTIFIED_DEFS_LEXICON_JSON as LexiconDoc,\n  LOCATION_LEXICON_JSON as LexiconDoc,\n  STRONGREF_LEXICON_JSON as LexiconDoc,\n  HYPERCERTS_DEFS_LEXICON_JSON as LexiconDoc,\n  ACTIVITY_LEXICON_JSON as LexiconDoc,\n  COLLECTION_LEXICON_JSON as LexiconDoc,\n  CONTRIBUTION_LEXICON_JSON as LexiconDoc,\n  EVALUATION_LEXICON_JSON as LexiconDoc,\n  EVIDENCE_LEXICON_JSON as LexiconDoc,\n  MEASUREMENT_LEXICON_JSON as LexiconDoc,\n  RIGHTS_LEXICON_JSON as LexiconDoc,\n  PROJECT_LEXICON_JSON as LexiconDoc,\n  BADGE_AWARD_LEXICON_JSON as LexiconDoc,\n  BADGE_DEFINITION_LEXICON_JSON as LexiconDoc,\n  BADGE_RESPONSE_LEXICON_JSON as LexiconDoc,\n  FUNDING_RECEIPT_LEXICON_JSON as LexiconDoc,\n];\n\n/**\n * Collection NSIDs (Namespaced Identifiers) for hypercert records.\n *\n * Use these constants when performing record operations to ensure\n * correct collection names.\n */\nexport const HYPERCERT_COLLECTIONS = {\n  /**\n   * Main hypercert claim record collection.\n   */\n  CLAIM: ACTIVITY_NSID,\n\n  /**\n   * Rights record collection.\n   */\n  RIGHTS: RIGHTS_NSID,\n\n  /**\n   * Location record collection (shared certified lexicon).\n   */\n  LOCATION: LOCATION_NSID,\n\n  /**\n   * Contribution record collection.\n   */\n  CONTRIBUTION: CONTRIBUTION_NSID,\n\n  /**\n   * Measurement record collection.\n   */\n  MEASUREMENT: MEASUREMENT_NSID,\n\n  /**\n   * Evaluation record collection.\n   */\n  EVALUATION: EVALUATION_NSID,\n\n  /**\n   * Evidence record collection.\n   */\n  EVIDENCE: EVIDENCE_NSID,\n\n  /**\n   * Collection record collection (groups of hypercerts).\n   */\n  COLLECTION: COLLECTION_NSID,\n\n  /**\n   * Project record collection.\n   */\n  PROJECT: PROJECT_NSID,\n\n  /**\n   * Badge award record collection.\n   */\n  BADGE_AWARD: BADGE_AWARD_NSID,\n\n  /**\n   * Badge definition record collection.\n   */\n  BADGE_DEFINITION: BADGE_DEFINITION_NSID,\n\n  /**\n   * Badge response record collection.\n   */\n  BADGE_RESPONSE: BADGE_RESPONSE_NSID,\n\n  /**\n   * Funding receipt record collection.\n   */\n  FUNDING_RECEIPT: FUNDING_RECEIPT_NSID,\n} as const;\n"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0DG;AAqCH;;;AAGG;AACI,MAAM,kBAAkB,GAAiB;IAC9C,2BAAyC;IACzC,qBAAmC;IACnC,sBAAoC;IACpC,4BAA0C;IAC1C,qBAAmC;IACnC,uBAAqC;IACrC,yBAAuC;IACvC,uBAAqC;IACrC,qBAAmC;IACnC,wBAAsC;IACtC,mBAAiC;IACjC,oBAAkC;IAClC,wBAAsC;IACtC,6BAA2C;IAC3C,2BAAyC;IACzC,4BAA0C;;AAG5C;;;;;AAKG;AACI,MAAM,qBAAqB,GAAG;AACnC;;AAEG;AACH,IAAA,KAAK,EAAE,aAAa;AAEpB;;AAEG;AACH,IAAA,MAAM,EAAE,WAAW;AAEnB;;AAEG;AACH,IAAA,QAAQ,EAAE,aAAa;AAEvB;;AAEG;AACH,IAAA,YAAY,EAAE,iBAAiB;AAE/B;;AAEG;AACH,IAAA,WAAW,EAAE,gBAAgB;AAE7B;;AAEG;AACH,IAAA,UAAU,EAAE,eAAe;AAE3B;;AAEG;AACH,IAAA,QAAQ,EAAE,aAAa;AAEvB;;AAEG;AACH,IAAA,UAAU,EAAE,eAAe;AAE3B;;AAEG;AACH,IAAA,OAAO,EAAE,YAAY;AAErB;;AAEG;AACH,IAAA,WAAW,EAAE,gBAAgB;AAE7B;;AAEG;AACH,IAAA,gBAAgB,EAAE,qBAAqB;AAEvC;;AAEG;AACH,IAAA,cAAc,EAAE,mBAAmB;AAEnC;;AAEG;AACH,IAAA,eAAe,EAAE,oBAAoB;;;;;"}

package/dist/testing.d.ts

@@ -366,7 +366,32 @@ declare const OAuthConfigSchema: z.ZodObject<{
     redirectUri: z.ZodString;
     /**
      * OAuth scopes to request, space-separated.
-     * Common scopes: "atproto", "transition:generic"
+     *
+     * Can be a string of space-separated permissions or use the permission system:
+     *
+     * @example Using presets
+     * ```typescript
+     * import { ScopePresets } from '@hypercerts-org/sdk-core';
+     * scope: ScopePresets.EMAIL_AND_PROFILE
+     * ```
+     *
+     * @example Building custom scopes
+     * ```typescript
+     * import { PermissionBuilder, buildScope } from '@hypercerts-org/sdk-core';
+     * scope: buildScope(
+     *   new PermissionBuilder()
+     *     .accountEmail('read')
+     *     .repoWrite('app.bsky.feed.post')
+     *     .build()
+     * )
+     * ```
+     *
+     * @example Legacy scopes
+     * ```typescript
+     * scope: "atproto transition:generic"
+     * ```
+     *
+     * @see https://atproto.com/specs/permission for permission details
      */
     scope: z.ZodString;
     /**

package/dist/types.cjs

@@ -1,6 +1,8 @@
 'use strict';
 
 var zod = require('zod');
+var lexicon = require('@atproto/lexicon');
+require('@hypercerts-org/lexicon');
 
 /**
  * Zod schema for OAuth configuration validation.
@@ -24,9 +26,34 @@ const OAuthConfigSchema = zod.z.object({
     redirectUri: zod.z.string().url(),
     /**
      * OAuth scopes to request, space-separated.
-     * Common scopes: "atproto", "transition:generic"
+     *
+     * Can be a string of space-separated permissions or use the permission system:
+     *
+     * @example Using presets
+     * ```typescript
+     * import { ScopePresets } from '@hypercerts-org/sdk-core';
+     * scope: ScopePresets.EMAIL_AND_PROFILE
+     * ```
+     *
+     * @example Building custom scopes
+     * ```typescript
+     * import { PermissionBuilder, buildScope } from '@hypercerts-org/sdk-core';
+     * scope: buildScope(
+     *   new PermissionBuilder()
+     *     .accountEmail('read')
+     *     .repoWrite('app.bsky.feed.post')
+     *     .build()
+     * )
+     * ```
+     *
+     * @example Legacy scopes
+     * ```typescript
+     * scope: "atproto transition:generic"
+     * ```
+     *
+     * @see https://atproto.com/specs/permission for permission details
      */
-    scope: zod.z.string(),
+    scope: zod.z.string().min(1, "OAuth scope is required"),
     /**
      * URL to your public JWKS (JSON Web Key Set) endpoint.
      * Used by the authorization server to verify your client's signatures.
@@ -211,6 +238,10 @@ const CollaboratorSchema = zod.z.object({
     revokedAt: zod.z.string().optional(),
 });
 
+Object.defineProperty(exports, "BlobRef", {
+    enumerable: true,
+    get: function () { return lexicon.BlobRef; }
+});
 exports.ATProtoSDKConfigSchema = ATProtoSDKConfigSchema;
 exports.CollaboratorPermissionsSchema = CollaboratorPermissionsSchema;
 exports.CollaboratorSchema = CollaboratorSchema;