@epochcore/identity-sdk 1.0.0 → 1.2.0

package/dist/index.d.mts

@@ -0,0 +1,177 @@
+/**
+ * @epochcore/identity-sdk
+ * World's First Universal Infrastructure Identity SDK
+ *
+ * Provides Ed25519 cryptographic identities for:
+ * - Cloudflare Workers
+ * - D1 Databases
+ * - R2 Storage Buckets
+ * - Durable Objects
+ * - Local Daemons
+ */
+type IdentityType = 'worker' | 'database' | 'storage' | 'durable_object' | 'daemon';
+interface EpochCoreIdentity {
+    did: string;
+    publicKey: string;
+    fingerprint: string;
+    type: IdentityType;
+    name: string;
+    createdAt: string;
+}
+interface EpochCoreWallet {
+    address: string;
+    publicKey: string;
+    identityDid: string;
+}
+interface SignedPayload {
+    payload: string;
+    signature: string;
+    publicKey: string;
+    timestamp: string;
+}
+interface QuantumResistantKeypair {
+    /** ML-DSA-65 (CRYSTALS-Dilithium3) secret key — hex-encoded */
+    secretKey: string;
+    /** ML-DSA-65 public key — hex-encoded */
+    publicKey: string;
+    /** Algorithm identifier */
+    algorithm: 'ML-DSA-65';
+}
+interface HybridIdentity {
+    /** Standard Ed25519 identity */
+    classical: EpochCoreIdentity;
+    /** Post-quantum ML-DSA-65 public key — hex-encoded */
+    quantumPublicKey: string;
+    /** DID with quantum-resistant tag */
+    quantumDid: string;
+}
+interface HybridSignedPayload {
+    payload: string;
+    /** Ed25519 signature — hex */
+    classicalSignature: string;
+    /** ML-DSA-65 signature — hex */
+    quantumSignature: string;
+    /** Ed25519 public key — hex */
+    classicalPublicKey: string;
+    /** ML-DSA-65 public key — hex */
+    quantumPublicKey: string;
+    timestamp: string;
+}
+/**
+ * Generate a new Ed25519 keypair for infrastructure identity
+ */
+declare function generateKeypair(): Promise<{
+    privateKey: string;
+    publicKey: string;
+}>;
+/**
+ * Create a DID (Decentralized Identifier) for infrastructure
+ * Format: did:epochcore:<type>:<name>:<fingerprint>
+ */
+declare function createDID(type: IdentityType, name: string, publicKey: string): string;
+/**
+ * Generate a complete infrastructure identity
+ */
+declare function generateIdentity(type: IdentityType, name: string): Promise<{
+    identity: EpochCoreIdentity;
+    privateKey: string;
+}>;
+/**
+ * Derive a secp256k1 wallet from an identity for Web3 operations
+ */
+declare function deriveWallet(privateKey: string, identityDid: string): EpochCoreWallet;
+/**
+ * Sign a payload with Ed25519 private key
+ */
+declare function signPayload(payload: string, privateKey: string): Promise<SignedPayload>;
+/**
+ * Verify an Ed25519 signature
+ */
+declare function verifySignature(payload: string, signature: string, publicKey: string): Promise<boolean>;
+/**
+ * Parse a DID string into components
+ */
+declare function parseDID(did: string): {
+    method: string;
+    type: IdentityType;
+    name: string;
+    fingerprint: string;
+} | null;
+/**
+ * Generate JWKS (JSON Web Key Set) for OAuth2/OIDC integration
+ */
+declare function generateJWKS(publicKeys: string[]): {
+    keys: Array<{
+        kty: string;
+        crv: string;
+        x: string;
+        use: string;
+        kid: string;
+    }>;
+};
+/**
+ * Generate a post-quantum ML-DSA-65 keypair.
+ * ML-DSA-65 (Dilithium3) provides NIST Security Level 3 — resistant to
+ * both classical and quantum attacks (Shor's algorithm).
+ *
+ * @param seed - Optional 32-byte seed (hex). If omitted, uses CSPRNG.
+ */
+declare function generateQuantumKeypair(seed?: string): QuantumResistantKeypair;
+/**
+ * Generate a hybrid identity with both Ed25519 (classical) and ML-DSA-65
+ * (post-quantum) keys. This provides quantum-resistance while maintaining
+ * backward compatibility with existing Ed25519 infrastructure.
+ */
+declare function generateQuantumResistantIdentity(type: IdentityType, name: string): Promise<{
+    hybrid: HybridIdentity;
+    classicalPrivateKey: string;
+    quantumSecretKey: string;
+}>;
+/**
+ * Sign a payload with both Ed25519 and ML-DSA-65 (hybrid signature).
+ * Verifiers can check either or both signatures — providing quantum
+ * safety while maintaining classical compatibility.
+ *
+ * @param payload - String data to sign
+ * @param classicalPrivateKey - Ed25519 private key (64 hex chars)
+ * @param quantumSecretKey - ML-DSA-65 secret key (hex, 8064 chars / 4032 bytes)
+ * @param quantumPublicKey - ML-DSA-65 public key (hex, 3904 chars / 1952 bytes)
+ */
+declare function signPayloadHybrid(payload: string, classicalPrivateKey: string, quantumSecretKey: string, quantumPublicKey: string): Promise<HybridSignedPayload>;
+/**
+ * Verify a hybrid signature (Ed25519 + ML-DSA-65).
+ * Returns true only if BOTH signatures are valid.
+ */
+declare function verifySignatureHybrid(payload: string, classicalSignature: string, quantumSignature: string, classicalPublicKey: string, quantumPublicKey: string): Promise<boolean>;
+declare const CONSTANTS: {
+    DID_PREFIX: string;
+    SIGNING_ALGORITHM: string;
+    PQ_SIGNING_ALGORITHM: string;
+    WALLET_ALGORITHM: string;
+    SUPPORTED_TYPES: IdentityType[];
+    VERSION: string;
+};
+declare const _default: {
+    generateKeypair: typeof generateKeypair;
+    generateIdentity: typeof generateIdentity;
+    generateQuantumKeypair: typeof generateQuantumKeypair;
+    generateQuantumResistantIdentity: typeof generateQuantumResistantIdentity;
+    createDID: typeof createDID;
+    parseDID: typeof parseDID;
+    deriveWallet: typeof deriveWallet;
+    signPayload: typeof signPayload;
+    signPayloadHybrid: typeof signPayloadHybrid;
+    verifySignature: typeof verifySignature;
+    verifySignatureHybrid: typeof verifySignatureHybrid;
+    generateJWKS: typeof generateJWKS;
+    CONSTANTS: {
+        DID_PREFIX: string;
+        SIGNING_ALGORITHM: string;
+        PQ_SIGNING_ALGORITHM: string;
+        WALLET_ALGORITHM: string;
+        SUPPORTED_TYPES: IdentityType[];
+        VERSION: string;
+    };
+};
+
+export { CONSTANTS, type EpochCoreIdentity, type EpochCoreWallet, type HybridIdentity, type HybridSignedPayload, type IdentityType, type QuantumResistantKeypair, type SignedPayload, createDID, _default as default, deriveWallet, generateIdentity, generateJWKS, generateKeypair, generateQuantumKeypair, generateQuantumResistantIdentity, parseDID, signPayload, signPayloadHybrid, verifySignature, verifySignatureHybrid };

package/dist/index.d.ts

@@ -9,8 +9,8 @@
  * - Durable Objects
  * - Local Daemons
  */
-export type IdentityType = 'worker' | 'database' | 'storage' | 'durable_object' | 'daemon';
-export interface EpochCoreIdentity {
+type IdentityType = 'worker' | 'database' | 'storage' | 'durable_object' | 'daemon';
+interface EpochCoreIdentity {
     did: string;
     publicKey: string;
     fingerprint: string;
@@ -18,21 +18,49 @@ export interface EpochCoreIdentity {
     name: string;
     createdAt: string;
 }
-export interface EpochCoreWallet {
+interface EpochCoreWallet {
     address: string;
     publicKey: string;
     identityDid: string;
 }
-export interface SignedPayload {
+interface SignedPayload {
     payload: string;
     signature: string;
     publicKey: string;
     timestamp: string;
 }
+interface QuantumResistantKeypair {
+    /** ML-DSA-65 (CRYSTALS-Dilithium3) secret key — hex-encoded */
+    secretKey: string;
+    /** ML-DSA-65 public key — hex-encoded */
+    publicKey: string;
+    /** Algorithm identifier */
+    algorithm: 'ML-DSA-65';
+}
+interface HybridIdentity {
+    /** Standard Ed25519 identity */
+    classical: EpochCoreIdentity;
+    /** Post-quantum ML-DSA-65 public key — hex-encoded */
+    quantumPublicKey: string;
+    /** DID with quantum-resistant tag */
+    quantumDid: string;
+}
+interface HybridSignedPayload {
+    payload: string;
+    /** Ed25519 signature — hex */
+    classicalSignature: string;
+    /** ML-DSA-65 signature — hex */
+    quantumSignature: string;
+    /** Ed25519 public key — hex */
+    classicalPublicKey: string;
+    /** ML-DSA-65 public key — hex */
+    quantumPublicKey: string;
+    timestamp: string;
+}
 /**
  * Generate a new Ed25519 keypair for infrastructure identity
  */
-export declare function generateKeypair(): Promise<{
+declare function generateKeypair(): Promise<{
     privateKey: string;
     publicKey: string;
 }>;
@@ -40,30 +68,30 @@ export declare function generateKeypair(): Promise<{
  * Create a DID (Decentralized Identifier) for infrastructure
  * Format: did:epochcore:<type>:<name>:<fingerprint>
  */
-export declare function createDID(type: IdentityType, name: string, publicKey: string): string;
+declare function createDID(type: IdentityType, name: string, publicKey: string): string;
 /**
  * Generate a complete infrastructure identity
  */
-export declare function generateIdentity(type: IdentityType, name: string): Promise<{
+declare function generateIdentity(type: IdentityType, name: string): Promise<{
     identity: EpochCoreIdentity;
     privateKey: string;
 }>;
 /**
  * Derive a secp256k1 wallet from an identity for Web3 operations
  */
-export declare function deriveWallet(privateKey: string, identityDid: string): EpochCoreWallet;
+declare function deriveWallet(privateKey: string, identityDid: string): EpochCoreWallet;
 /**
  * Sign a payload with Ed25519 private key
  */
-export declare function signPayload(payload: string, privateKey: string): Promise<SignedPayload>;
+declare function signPayload(payload: string, privateKey: string): Promise<SignedPayload>;
 /**
  * Verify an Ed25519 signature
  */
-export declare function verifySignature(payload: string, signature: string, publicKey: string): Promise<boolean>;
+declare function verifySignature(payload: string, signature: string, publicKey: string): Promise<boolean>;
 /**
  * Parse a DID string into components
  */
-export declare function parseDID(did: string): {
+declare function parseDID(did: string): {
     method: string;
     type: IdentityType;
     name: string;
@@ -72,7 +100,7 @@ export declare function parseDID(did: string): {
 /**
  * Generate JWKS (JSON Web Key Set) for OAuth2/OIDC integration
  */
-export declare function generateJWKS(publicKeys: string[]): {
+declare function generateJWKS(publicKeys: string[]): {
     keys: Array<{
         kty: string;
         crv: string;
@@ -81,9 +109,44 @@ export declare function generateJWKS(publicKeys: string[]): {
         kid: string;
     }>;
 };
-export declare const CONSTANTS: {
+/**
+ * Generate a post-quantum ML-DSA-65 keypair.
+ * ML-DSA-65 (Dilithium3) provides NIST Security Level 3 — resistant to
+ * both classical and quantum attacks (Shor's algorithm).
+ *
+ * @param seed - Optional 32-byte seed (hex). If omitted, uses CSPRNG.
+ */
+declare function generateQuantumKeypair(seed?: string): QuantumResistantKeypair;
+/**
+ * Generate a hybrid identity with both Ed25519 (classical) and ML-DSA-65
+ * (post-quantum) keys. This provides quantum-resistance while maintaining
+ * backward compatibility with existing Ed25519 infrastructure.
+ */
+declare function generateQuantumResistantIdentity(type: IdentityType, name: string): Promise<{
+    hybrid: HybridIdentity;
+    classicalPrivateKey: string;
+    quantumSecretKey: string;
+}>;
+/**
+ * Sign a payload with both Ed25519 and ML-DSA-65 (hybrid signature).
+ * Verifiers can check either or both signatures — providing quantum
+ * safety while maintaining classical compatibility.
+ *
+ * @param payload - String data to sign
+ * @param classicalPrivateKey - Ed25519 private key (64 hex chars)
+ * @param quantumSecretKey - ML-DSA-65 secret key (hex, 8064 chars / 4032 bytes)
+ * @param quantumPublicKey - ML-DSA-65 public key (hex, 3904 chars / 1952 bytes)
+ */
+declare function signPayloadHybrid(payload: string, classicalPrivateKey: string, quantumSecretKey: string, quantumPublicKey: string): Promise<HybridSignedPayload>;
+/**
+ * Verify a hybrid signature (Ed25519 + ML-DSA-65).
+ * Returns true only if BOTH signatures are valid.
+ */
+declare function verifySignatureHybrid(payload: string, classicalSignature: string, quantumSignature: string, classicalPublicKey: string, quantumPublicKey: string): Promise<boolean>;
+declare const CONSTANTS: {
     DID_PREFIX: string;
     SIGNING_ALGORITHM: string;
+    PQ_SIGNING_ALGORITHM: string;
     WALLET_ALGORITHM: string;
     SUPPORTED_TYPES: IdentityType[];
     VERSION: string;
@@ -91,19 +154,24 @@ export declare const CONSTANTS: {
 declare const _default: {
     generateKeypair: typeof generateKeypair;
     generateIdentity: typeof generateIdentity;
+    generateQuantumKeypair: typeof generateQuantumKeypair;
+    generateQuantumResistantIdentity: typeof generateQuantumResistantIdentity;
     createDID: typeof createDID;
     parseDID: typeof parseDID;
     deriveWallet: typeof deriveWallet;
     signPayload: typeof signPayload;
+    signPayloadHybrid: typeof signPayloadHybrid;
     verifySignature: typeof verifySignature;
+    verifySignatureHybrid: typeof verifySignatureHybrid;
     generateJWKS: typeof generateJWKS;
     CONSTANTS: {
         DID_PREFIX: string;
         SIGNING_ALGORITHM: string;
+        PQ_SIGNING_ALGORITHM: string;
         WALLET_ALGORITHM: string;
         SUPPORTED_TYPES: IdentityType[];
         VERSION: string;
     };
 };
-export default _default;
-//# sourceMappingURL=index.d.ts.map
+
+export { CONSTANTS, type EpochCoreIdentity, type EpochCoreWallet, type HybridIdentity, type HybridSignedPayload, type IdentityType, type QuantumResistantKeypair, type SignedPayload, createDID, _default as default, deriveWallet, generateIdentity, generateJWKS, generateKeypair, generateQuantumKeypair, generateQuantumResistantIdentity, parseDID, signPayload, signPayloadHybrid, verifySignature, verifySignatureHybrid };

package/dist/index.js

@@ -1,138 +1,339 @@
-/**
- * @epochcore/identity-sdk
- * World's First Universal Infrastructure Identity SDK
- *
- * Provides Ed25519 cryptographic identities for:
- * - Cloudflare Workers
- * - D1 Databases
- * - R2 Storage Buckets
- * - Durable Objects
- * - Local Daemons
- */
-import * as ed25519 from '@noble/ed25519';
-import * as secp256k1 from '@noble/secp256k1';
-import { sha256 } from '@noble/hashes/sha256';
-import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
-/**
- * Generate a new Ed25519 keypair for infrastructure identity
- */
-export async function generateKeypair() {
-    const privateKey = ed25519.utils.randomPrivateKey();
-    const publicKey = await ed25519.getPublicKeyAsync(privateKey);
-    return {
-        privateKey: bytesToHex(privateKey),
-        publicKey: bytesToHex(publicKey)
-    };
-}
-/**
- * Create a DID (Decentralized Identifier) for infrastructure
- * Format: did:epochcore:<type>:<name>:<fingerprint>
- */
-export function createDID(type, name, publicKey) {
-    const fingerprint = bytesToHex(sha256(hexToBytes(publicKey))).slice(0, 16);
-    return `did:epochcore:${type}:${name}:${fingerprint}`;
-}
-/**
- * Generate a complete infrastructure identity
- */
-export async function generateIdentity(type, name) {
-    const { privateKey, publicKey } = await generateKeypair();
-    const fingerprint = bytesToHex(sha256(hexToBytes(publicKey))).slice(0, 16);
-    const did = createDID(type, name, publicKey);
-    return {
-        identity: {
-            did,
-            publicKey,
-            fingerprint,
-            type,
-            name,
-            createdAt: new Date().toISOString()
-        },
-        privateKey
-    };
-}
-/**
- * Derive a secp256k1 wallet from an identity for Web3 operations
- */
-export function deriveWallet(privateKey, identityDid) {
-    const seedBytes = sha256(hexToBytes(privateKey));
-    const walletPrivKey = secp256k1.utils.normPrivateKeyToScalar(seedBytes);
-    const walletPubKey = secp256k1.getPublicKey(walletPrivKey, false);
-    // Ethereum-style address derivation
-    const pubKeyHash = sha256(walletPubKey.slice(1));
-    const address = '0x' + bytesToHex(pubKeyHash).slice(-40);
-    return {
-        address,
-        publicKey: bytesToHex(walletPubKey),
-        identityDid
-    };
-}
-/**
- * Sign a payload with Ed25519 private key
- */
-export async function signPayload(payload, privateKey) {
-    const message = new TextEncoder().encode(payload);
-    const signature = await ed25519.signAsync(message, hexToBytes(privateKey));
-    const publicKey = await ed25519.getPublicKeyAsync(hexToBytes(privateKey));
-    return {
-        payload,
-        signature: bytesToHex(signature),
-        publicKey: bytesToHex(publicKey),
-        timestamp: new Date().toISOString()
-    };
-}
-/**
- * Verify an Ed25519 signature
- */
-export async function verifySignature(payload, signature, publicKey) {
-    const message = new TextEncoder().encode(payload);
-    return ed25519.verifyAsync(hexToBytes(signature), message, hexToBytes(publicKey));
-}
-/**
- * Parse a DID string into components
- */
-export function parseDID(did) {
-    const parts = did.split(':');
-    if (parts.length !== 5 || parts[0] !== 'did' || parts[1] !== 'epochcore') {
-        return null;
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CONSTANTS: () => CONSTANTS,
+  createDID: () => createDID,
+  default: () => index_default,
+  deriveWallet: () => deriveWallet,
+  generateIdentity: () => generateIdentity,
+  generateJWKS: () => generateJWKS,
+  generateKeypair: () => generateKeypair,
+  generateQuantumKeypair: () => generateQuantumKeypair,
+  generateQuantumResistantIdentity: () => generateQuantumResistantIdentity,
+  parseDID: () => parseDID,
+  signPayload: () => signPayload,
+  signPayloadHybrid: () => signPayloadHybrid,
+  verifySignature: () => verifySignature,
+  verifySignatureHybrid: () => verifySignatureHybrid
+});
+module.exports = __toCommonJS(index_exports);
+var ed25519 = __toESM(require("@noble/ed25519"));
+var secp256k1 = __toESM(require("@noble/secp256k1"));
+var import_sha256 = require("@noble/hashes/sha256");
+var import_utils = require("@noble/hashes/utils");
+var import_ml_dsa = require("@noble/post-quantum/ml-dsa");
+var HEX_64_RE = /^[0-9a-f]{64}$/i;
+var NAME_RE = /^[\w.-]{1,128}$/;
+var MAX_DID_LENGTH = 512;
+var MAX_PAYLOAD_BYTES = 1048576;
+var SECP256K1_ORDER = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
+function toBase64Url(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  const base64 = btoa(binary);
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function validateHex64(value, name) {
+  if (typeof value !== "string" || !HEX_64_RE.test(value)) {
+    throw new TypeError(`${name} must be a 64-character hex string`);
+  }
+}
+function validateType(type) {
+  if (typeof type !== "string" || !CONSTANTS.SUPPORTED_TYPES.includes(type)) {
+    throw new TypeError(
+      `Invalid identity type: ${String(type)}. Must be one of: ${CONSTANTS.SUPPORTED_TYPES.join(", ")}`
+    );
+  }
+}
+function validateName(name) {
+  if (typeof name !== "string" || !NAME_RE.test(name)) {
+    throw new TypeError("name must be 1-128 characters matching /^[\\w.-]+$/");
+  }
+}
+async function generateKeypair() {
+  const privateKey = ed25519.utils.randomPrivateKey();
+  let allZero = true;
+  for (let i = 0; i < privateKey.length; i++) {
+    if (privateKey[i] !== 0) {
+      allZero = false;
+      break;
     }
-    return {
-        method: parts[1],
-        type: parts[2],
-        name: parts[3],
-        fingerprint: parts[4]
-    };
-}
-/**
- * Generate JWKS (JSON Web Key Set) for OAuth2/OIDC integration
- */
-export function generateJWKS(publicKeys) {
-    return {
-        keys: publicKeys.map((pk, i) => ({
-            kty: 'OKP',
-            crv: 'Ed25519',
-            x: Buffer.from(hexToBytes(pk)).toString('base64url'),
-            use: 'sig',
-            kid: `epochcore-${i + 1}`
-        }))
-    };
-}
-// Constants
-export const CONSTANTS = {
-    DID_PREFIX: 'did:epochcore',
-    SIGNING_ALGORITHM: 'Ed25519',
-    WALLET_ALGORITHM: 'secp256k1',
-    SUPPORTED_TYPES: ['worker', 'database', 'storage', 'durable_object', 'daemon'],
-    VERSION: '1.0.0'
+  }
+  if (allZero) {
+    throw new Error("Key generation produced zero-entropy private key; CSPRNG may be broken");
+  }
+  const publicKey = await ed25519.getPublicKeyAsync(privateKey);
+  return {
+    privateKey: (0, import_utils.bytesToHex)(privateKey),
+    publicKey: (0, import_utils.bytesToHex)(publicKey)
+  };
+}
+function createDID(type, name, publicKey) {
+  validateType(type);
+  validateName(name);
+  validateHex64(publicKey, "publicKey");
+  const fingerprint = (0, import_utils.bytesToHex)((0, import_sha256.sha256)((0, import_utils.hexToBytes)(publicKey))).slice(0, 32);
+  return `did:epochcore:${type}:${name}:${fingerprint}`;
+}
+async function generateIdentity(type, name) {
+  validateType(type);
+  validateName(name);
+  const { privateKey, publicKey } = await generateKeypair();
+  const fingerprint = (0, import_utils.bytesToHex)((0, import_sha256.sha256)((0, import_utils.hexToBytes)(publicKey))).slice(0, 32);
+  const did = createDID(type, name, publicKey);
+  return {
+    identity: {
+      did,
+      publicKey,
+      fingerprint,
+      type,
+      name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    privateKey
+  };
+}
+function deriveWallet(privateKey, identityDid) {
+  validateHex64(privateKey, "privateKey");
+  if (typeof identityDid !== "string" || !identityDid.startsWith("did:epochcore:")) {
+    throw new TypeError('identityDid must start with "did:epochcore:"');
+  }
+  const seedBytes = (0, import_sha256.sha256)((0, import_utils.hexToBytes)(privateKey));
+  const walletPrivKey = secp256k1.utils.normPrivateKeyToScalar(seedBytes);
+  if (walletPrivKey <= 0n || walletPrivKey >= SECP256K1_ORDER) {
+    throw new RangeError("Derived wallet private key scalar is out of valid secp256k1 range [1, n-1]");
+  }
+  const walletPubKey = secp256k1.getPublicKey(walletPrivKey, false);
+  const pubKeyHash = (0, import_sha256.sha256)(walletPubKey.slice(1));
+  const address = "0x" + (0, import_utils.bytesToHex)(pubKeyHash).slice(-40);
+  return {
+    address,
+    publicKey: (0, import_utils.bytesToHex)(walletPubKey),
+    identityDid
+  };
+}
+async function signPayload(payload, privateKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  const payloadBytes = new TextEncoder().encode(payload);
+  if (payloadBytes.byteLength > MAX_PAYLOAD_BYTES) {
+    throw new RangeError(`payload exceeds maximum size of ${MAX_PAYLOAD_BYTES} bytes`);
+  }
+  validateHex64(privateKey, "privateKey");
+  const signature = await ed25519.signAsync(payloadBytes, (0, import_utils.hexToBytes)(privateKey));
+  const publicKey = await ed25519.getPublicKeyAsync((0, import_utils.hexToBytes)(privateKey));
+  return {
+    payload,
+    signature: (0, import_utils.bytesToHex)(signature),
+    publicKey: (0, import_utils.bytesToHex)(publicKey),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function verifySignature(payload, signature, publicKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  if (typeof signature !== "string" || !/^[0-9a-f]{128}$/i.test(signature)) {
+    throw new TypeError("signature must be a 128-character hex string");
+  }
+  validateHex64(publicKey, "publicKey");
+  const message = new TextEncoder().encode(payload);
+  return ed25519.verifyAsync(
+    (0, import_utils.hexToBytes)(signature),
+    message,
+    (0, import_utils.hexToBytes)(publicKey)
+  );
+}
+function parseDID(did) {
+  if (typeof did !== "string" || did.length > MAX_DID_LENGTH) {
+    return null;
+  }
+  const parts = did.split(":");
+  if (parts.length !== 5 || parts[0] !== "did" || parts[1] !== "epochcore") {
+    return null;
+  }
+  if (!CONSTANTS.SUPPORTED_TYPES.includes(parts[2])) {
+    return null;
+  }
+  return {
+    method: parts[1],
+    type: parts[2],
+    name: parts[3],
+    fingerprint: parts[4]
+  };
+}
+function generateJWKS(publicKeys) {
+  if (!Array.isArray(publicKeys)) {
+    throw new TypeError("publicKeys must be an array");
+  }
+  for (let i = 0; i < publicKeys.length; i++) {
+    validateHex64(publicKeys[i], `publicKeys[${i}]`);
+  }
+  return {
+    keys: publicKeys.map((pk, i) => ({
+      kty: "OKP",
+      crv: "Ed25519",
+      x: toBase64Url((0, import_utils.hexToBytes)(pk)),
+      use: "sig",
+      kid: `epochcore-${i + 1}`
+    }))
+  };
+}
+function generateQuantumKeypair(seed) {
+  let seedBytes;
+  if (seed) {
+    if (typeof seed !== "string" || !/^[0-9a-f]{64}$/i.test(seed)) {
+      throw new TypeError("seed must be a 64-character hex string (32 bytes)");
+    }
+    seedBytes = (0, import_utils.hexToBytes)(seed);
+  } else {
+    seedBytes = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(seedBytes);
+  }
+  const { secretKey, publicKey } = import_ml_dsa.ml_dsa65.keygen(seedBytes);
+  return {
+    secretKey: (0, import_utils.bytesToHex)(secretKey),
+    publicKey: (0, import_utils.bytesToHex)(publicKey),
+    algorithm: "ML-DSA-65"
+  };
+}
+async function generateQuantumResistantIdentity(type, name) {
+  validateType(type);
+  validateName(name);
+  const { identity, privateKey: classicalPrivateKey } = await generateIdentity(type, name);
+  const quantumKeypair = generateQuantumKeypair();
+  const qFingerprint = (0, import_utils.bytesToHex)((0, import_sha256.sha256)((0, import_utils.hexToBytes)(quantumKeypair.publicKey.slice(0, 64)))).slice(0, 32);
+  const quantumDid = `did:epochcore:pq:${type}:${name}:${qFingerprint}`;
+  return {
+    hybrid: {
+      classical: identity,
+      quantumPublicKey: quantumKeypair.publicKey,
+      quantumDid
+    },
+    classicalPrivateKey,
+    quantumSecretKey: quantumKeypair.secretKey
+  };
+}
+async function signPayloadHybrid(payload, classicalPrivateKey, quantumSecretKey, quantumPublicKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  const payloadBytes = new TextEncoder().encode(payload);
+  if (payloadBytes.byteLength > MAX_PAYLOAD_BYTES) {
+    throw new RangeError(`payload exceeds maximum size of ${MAX_PAYLOAD_BYTES} bytes`);
+  }
+  validateHex64(classicalPrivateKey, "classicalPrivateKey");
+  if (typeof quantumSecretKey !== "string" || quantumSecretKey.length === 0) {
+    throw new TypeError("quantumSecretKey must be a non-empty hex string");
+  }
+  if (typeof quantumPublicKey !== "string" || quantumPublicKey.length === 0) {
+    throw new TypeError("quantumPublicKey must be a non-empty hex string");
+  }
+  const classicalSig = await ed25519.signAsync(payloadBytes, (0, import_utils.hexToBytes)(classicalPrivateKey));
+  const classicalPub = await ed25519.getPublicKeyAsync((0, import_utils.hexToBytes)(classicalPrivateKey));
+  const quantumSig = import_ml_dsa.ml_dsa65.sign((0, import_utils.hexToBytes)(quantumSecretKey), payloadBytes);
+  return {
+    payload,
+    classicalSignature: (0, import_utils.bytesToHex)(classicalSig),
+    quantumSignature: (0, import_utils.bytesToHex)(quantumSig),
+    classicalPublicKey: (0, import_utils.bytesToHex)(classicalPub),
+    quantumPublicKey,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function verifySignatureHybrid(payload, classicalSignature, quantumSignature, classicalPublicKey, quantumPublicKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  const payloadBytes = new TextEncoder().encode(payload);
+  if (typeof classicalSignature !== "string" || !/^[0-9a-f]{128}$/i.test(classicalSignature)) {
+    throw new TypeError("classicalSignature must be a 128-character hex string");
+  }
+  validateHex64(classicalPublicKey, "classicalPublicKey");
+  const classicalValid = await ed25519.verifyAsync(
+    (0, import_utils.hexToBytes)(classicalSignature),
+    payloadBytes,
+    (0, import_utils.hexToBytes)(classicalPublicKey)
+  );
+  if (typeof quantumSignature !== "string" || quantumSignature.length === 0) {
+    throw new TypeError("quantumSignature must be a non-empty hex string");
+  }
+  if (typeof quantumPublicKey !== "string" || quantumPublicKey.length === 0) {
+    throw new TypeError("quantumPublicKey must be a non-empty hex string");
+  }
+  const quantumValid = import_ml_dsa.ml_dsa65.verify(
+    (0, import_utils.hexToBytes)(quantumPublicKey),
+    payloadBytes,
+    (0, import_utils.hexToBytes)(quantumSignature)
+  );
+  return classicalValid && quantumValid;
+}
+var CONSTANTS = {
+  DID_PREFIX: "did:epochcore",
+  SIGNING_ALGORITHM: "Ed25519",
+  PQ_SIGNING_ALGORITHM: "ML-DSA-65",
+  WALLET_ALGORITHM: "secp256k1",
+  SUPPORTED_TYPES: ["worker", "database", "storage", "durable_object", "daemon"],
+  VERSION: "1.2.0"
 };
-export default {
-    generateKeypair,
-    generateIdentity,
-    createDID,
-    parseDID,
-    deriveWallet,
-    signPayload,
-    verifySignature,
-    generateJWKS,
-    CONSTANTS
+var index_default = {
+  generateKeypair,
+  generateIdentity,
+  generateQuantumKeypair,
+  generateQuantumResistantIdentity,
+  createDID,
+  parseDID,
+  deriveWallet,
+  signPayload,
+  signPayloadHybrid,
+  verifySignature,
+  verifySignatureHybrid,
+  generateJWKS,
+  CONSTANTS
 };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONSTANTS,
+  createDID,
+  deriveWallet,
+  generateIdentity,
+  generateJWKS,
+  generateKeypair,
+  generateQuantumKeypair,
+  generateQuantumResistantIdentity,
+  parseDID,
+  signPayload,
+  signPayloadHybrid,
+  verifySignature,
+  verifySignatureHybrid
+});

package/dist/index.mjs

@@ -0,0 +1,292 @@
+// src/index.ts
+import * as ed25519 from "@noble/ed25519";
+import * as secp256k1 from "@noble/secp256k1";
+import { sha256 } from "@noble/hashes/sha256";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa";
+var HEX_64_RE = /^[0-9a-f]{64}$/i;
+var NAME_RE = /^[\w.-]{1,128}$/;
+var MAX_DID_LENGTH = 512;
+var MAX_PAYLOAD_BYTES = 1048576;
+var SECP256K1_ORDER = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
+function toBase64Url(bytes) {
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);
+  const base64 = btoa(binary);
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function validateHex64(value, name) {
+  if (typeof value !== "string" || !HEX_64_RE.test(value)) {
+    throw new TypeError(`${name} must be a 64-character hex string`);
+  }
+}
+function validateType(type) {
+  if (typeof type !== "string" || !CONSTANTS.SUPPORTED_TYPES.includes(type)) {
+    throw new TypeError(
+      `Invalid identity type: ${String(type)}. Must be one of: ${CONSTANTS.SUPPORTED_TYPES.join(", ")}`
+    );
+  }
+}
+function validateName(name) {
+  if (typeof name !== "string" || !NAME_RE.test(name)) {
+    throw new TypeError("name must be 1-128 characters matching /^[\\w.-]+$/");
+  }
+}
+async function generateKeypair() {
+  const privateKey = ed25519.utils.randomPrivateKey();
+  let allZero = true;
+  for (let i = 0; i < privateKey.length; i++) {
+    if (privateKey[i] !== 0) {
+      allZero = false;
+      break;
+    }
+  }
+  if (allZero) {
+    throw new Error("Key generation produced zero-entropy private key; CSPRNG may be broken");
+  }
+  const publicKey = await ed25519.getPublicKeyAsync(privateKey);
+  return {
+    privateKey: bytesToHex(privateKey),
+    publicKey: bytesToHex(publicKey)
+  };
+}
+function createDID(type, name, publicKey) {
+  validateType(type);
+  validateName(name);
+  validateHex64(publicKey, "publicKey");
+  const fingerprint = bytesToHex(sha256(hexToBytes(publicKey))).slice(0, 32);
+  return `did:epochcore:${type}:${name}:${fingerprint}`;
+}
+async function generateIdentity(type, name) {
+  validateType(type);
+  validateName(name);
+  const { privateKey, publicKey } = await generateKeypair();
+  const fingerprint = bytesToHex(sha256(hexToBytes(publicKey))).slice(0, 32);
+  const did = createDID(type, name, publicKey);
+  return {
+    identity: {
+      did,
+      publicKey,
+      fingerprint,
+      type,
+      name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    privateKey
+  };
+}
+function deriveWallet(privateKey, identityDid) {
+  validateHex64(privateKey, "privateKey");
+  if (typeof identityDid !== "string" || !identityDid.startsWith("did:epochcore:")) {
+    throw new TypeError('identityDid must start with "did:epochcore:"');
+  }
+  const seedBytes = sha256(hexToBytes(privateKey));
+  const walletPrivKey = secp256k1.utils.normPrivateKeyToScalar(seedBytes);
+  if (walletPrivKey <= 0n || walletPrivKey >= SECP256K1_ORDER) {
+    throw new RangeError("Derived wallet private key scalar is out of valid secp256k1 range [1, n-1]");
+  }
+  const walletPubKey = secp256k1.getPublicKey(walletPrivKey, false);
+  const pubKeyHash = sha256(walletPubKey.slice(1));
+  const address = "0x" + bytesToHex(pubKeyHash).slice(-40);
+  return {
+    address,
+    publicKey: bytesToHex(walletPubKey),
+    identityDid
+  };
+}
+async function signPayload(payload, privateKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  const payloadBytes = new TextEncoder().encode(payload);
+  if (payloadBytes.byteLength > MAX_PAYLOAD_BYTES) {
+    throw new RangeError(`payload exceeds maximum size of ${MAX_PAYLOAD_BYTES} bytes`);
+  }
+  validateHex64(privateKey, "privateKey");
+  const signature = await ed25519.signAsync(payloadBytes, hexToBytes(privateKey));
+  const publicKey = await ed25519.getPublicKeyAsync(hexToBytes(privateKey));
+  return {
+    payload,
+    signature: bytesToHex(signature),
+    publicKey: bytesToHex(publicKey),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function verifySignature(payload, signature, publicKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  if (typeof signature !== "string" || !/^[0-9a-f]{128}$/i.test(signature)) {
+    throw new TypeError("signature must be a 128-character hex string");
+  }
+  validateHex64(publicKey, "publicKey");
+  const message = new TextEncoder().encode(payload);
+  return ed25519.verifyAsync(
+    hexToBytes(signature),
+    message,
+    hexToBytes(publicKey)
+  );
+}
+function parseDID(did) {
+  if (typeof did !== "string" || did.length > MAX_DID_LENGTH) {
+    return null;
+  }
+  const parts = did.split(":");
+  if (parts.length !== 5 || parts[0] !== "did" || parts[1] !== "epochcore") {
+    return null;
+  }
+  if (!CONSTANTS.SUPPORTED_TYPES.includes(parts[2])) {
+    return null;
+  }
+  return {
+    method: parts[1],
+    type: parts[2],
+    name: parts[3],
+    fingerprint: parts[4]
+  };
+}
+function generateJWKS(publicKeys) {
+  if (!Array.isArray(publicKeys)) {
+    throw new TypeError("publicKeys must be an array");
+  }
+  for (let i = 0; i < publicKeys.length; i++) {
+    validateHex64(publicKeys[i], `publicKeys[${i}]`);
+  }
+  return {
+    keys: publicKeys.map((pk, i) => ({
+      kty: "OKP",
+      crv: "Ed25519",
+      x: toBase64Url(hexToBytes(pk)),
+      use: "sig",
+      kid: `epochcore-${i + 1}`
+    }))
+  };
+}
+function generateQuantumKeypair(seed) {
+  let seedBytes;
+  if (seed) {
+    if (typeof seed !== "string" || !/^[0-9a-f]{64}$/i.test(seed)) {
+      throw new TypeError("seed must be a 64-character hex string (32 bytes)");
+    }
+    seedBytes = hexToBytes(seed);
+  } else {
+    seedBytes = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(seedBytes);
+  }
+  const { secretKey, publicKey } = ml_dsa65.keygen(seedBytes);
+  return {
+    secretKey: bytesToHex(secretKey),
+    publicKey: bytesToHex(publicKey),
+    algorithm: "ML-DSA-65"
+  };
+}
+async function generateQuantumResistantIdentity(type, name) {
+  validateType(type);
+  validateName(name);
+  const { identity, privateKey: classicalPrivateKey } = await generateIdentity(type, name);
+  const quantumKeypair = generateQuantumKeypair();
+  const qFingerprint = bytesToHex(sha256(hexToBytes(quantumKeypair.publicKey.slice(0, 64)))).slice(0, 32);
+  const quantumDid = `did:epochcore:pq:${type}:${name}:${qFingerprint}`;
+  return {
+    hybrid: {
+      classical: identity,
+      quantumPublicKey: quantumKeypair.publicKey,
+      quantumDid
+    },
+    classicalPrivateKey,
+    quantumSecretKey: quantumKeypair.secretKey
+  };
+}
+async function signPayloadHybrid(payload, classicalPrivateKey, quantumSecretKey, quantumPublicKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  const payloadBytes = new TextEncoder().encode(payload);
+  if (payloadBytes.byteLength > MAX_PAYLOAD_BYTES) {
+    throw new RangeError(`payload exceeds maximum size of ${MAX_PAYLOAD_BYTES} bytes`);
+  }
+  validateHex64(classicalPrivateKey, "classicalPrivateKey");
+  if (typeof quantumSecretKey !== "string" || quantumSecretKey.length === 0) {
+    throw new TypeError("quantumSecretKey must be a non-empty hex string");
+  }
+  if (typeof quantumPublicKey !== "string" || quantumPublicKey.length === 0) {
+    throw new TypeError("quantumPublicKey must be a non-empty hex string");
+  }
+  const classicalSig = await ed25519.signAsync(payloadBytes, hexToBytes(classicalPrivateKey));
+  const classicalPub = await ed25519.getPublicKeyAsync(hexToBytes(classicalPrivateKey));
+  const quantumSig = ml_dsa65.sign(hexToBytes(quantumSecretKey), payloadBytes);
+  return {
+    payload,
+    classicalSignature: bytesToHex(classicalSig),
+    quantumSignature: bytesToHex(quantumSig),
+    classicalPublicKey: bytesToHex(classicalPub),
+    quantumPublicKey,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function verifySignatureHybrid(payload, classicalSignature, quantumSignature, classicalPublicKey, quantumPublicKey) {
+  if (typeof payload !== "string" || payload.length === 0) {
+    throw new TypeError("payload must be a non-empty string");
+  }
+  const payloadBytes = new TextEncoder().encode(payload);
+  if (typeof classicalSignature !== "string" || !/^[0-9a-f]{128}$/i.test(classicalSignature)) {
+    throw new TypeError("classicalSignature must be a 128-character hex string");
+  }
+  validateHex64(classicalPublicKey, "classicalPublicKey");
+  const classicalValid = await ed25519.verifyAsync(
+    hexToBytes(classicalSignature),
+    payloadBytes,
+    hexToBytes(classicalPublicKey)
+  );
+  if (typeof quantumSignature !== "string" || quantumSignature.length === 0) {
+    throw new TypeError("quantumSignature must be a non-empty hex string");
+  }
+  if (typeof quantumPublicKey !== "string" || quantumPublicKey.length === 0) {
+    throw new TypeError("quantumPublicKey must be a non-empty hex string");
+  }
+  const quantumValid = ml_dsa65.verify(
+    hexToBytes(quantumPublicKey),
+    payloadBytes,
+    hexToBytes(quantumSignature)
+  );
+  return classicalValid && quantumValid;
+}
+var CONSTANTS = {
+  DID_PREFIX: "did:epochcore",
+  SIGNING_ALGORITHM: "Ed25519",
+  PQ_SIGNING_ALGORITHM: "ML-DSA-65",
+  WALLET_ALGORITHM: "secp256k1",
+  SUPPORTED_TYPES: ["worker", "database", "storage", "durable_object", "daemon"],
+  VERSION: "1.2.0"
+};
+var index_default = {
+  generateKeypair,
+  generateIdentity,
+  generateQuantumKeypair,
+  generateQuantumResistantIdentity,
+  createDID,
+  parseDID,
+  deriveWallet,
+  signPayload,
+  signPayloadHybrid,
+  verifySignature,
+  verifySignatureHybrid,
+  generateJWKS,
+  CONSTANTS
+};
+export {
+  CONSTANTS,
+  createDID,
+  index_default as default,
+  deriveWallet,
+  generateIdentity,
+  generateJWKS,
+  generateKeypair,
+  generateQuantumKeypair,
+  generateQuantumResistantIdentity,
+  parseDID,
+  signPayload,
+  signPayloadHybrid,
+  verifySignature,
+  verifySignatureHybrid
+};

package/package.json

@@ -1,12 +1,20 @@
 {
   "name": "@epochcore/identity-sdk",
-  "version": "1.0.0",
-  "description": "World's First Universal Infrastructure Identity SDK - Ed25519 cryptographic identities for workers, databases, storage, and daemons",
+  "version": "1.2.0",
+  "description": "World's First Universal Infrastructure Identity SDK - Ed25519 + ML-DSA-65 (post-quantum) cryptographic identities for workers, databases, storage, and daemons",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
   "scripts": {
-    "build": "tsc",
-    "test": "vitest",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean --external @noble/ed25519 --external @noble/secp256k1 --external @noble/hashes --external @noble/post-quantum",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -15,6 +23,9 @@
     "infrastructure",
     "ed25519",
     "secp256k1",
+    "ml-dsa",
+    "dilithium",
+    "post-quantum",
     "web3",
     "cloudflare-workers",
     "quantum",
@@ -30,9 +41,11 @@
   "dependencies": {
     "@noble/ed25519": "^2.0.0",
     "@noble/secp256k1": "^2.0.0",
-    "@noble/hashes": "^1.3.0"
+    "@noble/hashes": "^1.3.0",
+    "@noble/post-quantum": "^0.2.0"
   },
   "devDependencies": {
+    "tsup": "^8.0.0",
     "typescript": "^5.3.0",
     "vitest": "^1.0.0"
   },

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,GAAG,gBAAgB,GAAG,QAAQ,CAAC;AAE3F,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC;IAC/C,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,CAQD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAChB,MAAM,CAGR;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IACT,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAgBD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB,eAAe,CAcjB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,aAAa,CAAC,CAWxB;AAED;;GAEG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,IAAI,CAYP;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG;IAClD,IAAI,EAAE,KAAK,CAAC;QACV,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;QACZ,CAAC,EAAE,MAAM,CAAC;QACV,GAAG,EAAE,MAAM,CAAC;QACZ,GAAG,EAAE,MAAM,CAAC;KACb,CAAC,CAAC;CACJ,CAUA;AAGD,eAAO,MAAM,SAAS;;;;qBAI8D,YAAY,EAAE;;CAEjG,CAAC;;;;;;;;;;;;;;yBAFkF,YAAY,EAAE;;;;AAIlG,wBAUE"}