@openentity/sdk 0.2.0 → 0.4.1

package/dist/index.js

@@ -1,1701 +1,92 @@
-// src/index.ts
-import jcs from "canonicalize";
-import { ed25519 } from "@noble/curves/ed25519.js";
-import { secp256k1 } from "@noble/curves/secp256k1.js";
-import { sha256 as nobleSha256 } from "@noble/hashes/sha2.js";
-import { keccak_256 } from "@noble/hashes/sha3.js";
-import { Validator } from "@cfworker/json-schema";
-
-// ../../spec/schemas/openentity-1.0.json
-var openentity_1_0_default = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "https://openentity.org/spec/1.0.json",
-  title: "Open Entity Identity Standard 1.0 (OEIS-1) object schemas",
-  $defs: {
-    spec: {
-      const: "openentity/1.0"
-    },
-    timestamp: {
-      type: "string",
-      pattern: "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z$"
-    },
-    did: {
-      type: "string",
-      maxLength: 512,
-      pattern: "^(did:[a-z0-9]+:[A-Za-z0-9._:%-]+|eid:base:0x[0-9a-fA-F]{40})$"
-    },
-    hex64: {
-      type: "string",
-      pattern: "^[0-9a-f]{64}$"
-    },
-    nonce: {
-      type: "string",
-      pattern: "^[1-9A-HJ-NP-Za-km-z]{16,44}$"
-    },
-    multibase: {
-      type: "string",
-      maxLength: 256,
-      pattern: "^z[1-9A-HJ-NP-Za-km-z]+$"
-    },
-    url: {
-      type: "string",
-      maxLength: 2048
-    },
-    statement: {
-      type: "string",
-      maxLength: 1e3
-    },
-    strings: {
-      type: "array",
-      maxItems: 64,
-      items: {
-        type: "string",
-        maxLength: 200
-      }
-    },
-    proof: {
-      type: "object",
-      required: [
-        "type",
-        "created",
-        "verificationMethod",
-        "proofPurpose",
-        "proofValue"
-      ],
-      properties: {
-        type: {
-          enum: [
-            "DataIntegrityProof",
-            "EthereumEip712Signature2021"
-          ]
-        },
-        cryptosuite: {
-          const: "eddsa-jcs-2022"
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        verificationMethod: {
-          type: "string",
-          maxLength: 1024
-        },
-        proofPurpose: {
-          const: "assertionMethod"
-        },
-        proofValue: {
-          type: "string",
-          maxLength: 256
-        }
-      }
-    },
-    EntityDocument: {
-      type: "object",
-      required: [
-        "spec",
-        "eid",
-        "name",
-        "description",
-        "created",
-        "updated",
-        "seq",
-        "keys",
-        "operator",
-        "substrate",
-        "layers",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        eid: {
-          $ref: "#/$defs/did"
-        },
-        name: {
-          type: "string",
-          minLength: 1,
-          maxLength: 80
-        },
-        description: {
-          type: "string",
-          minLength: 1,
-          maxLength: 500
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        updated: {
-          $ref: "#/$defs/timestamp"
-        },
-        seq: {
-          type: "integer",
-          minimum: 1
-        },
-        keys: {
-          type: "array",
-          minItems: 1,
-          maxItems: 16,
-          items: {
-            type: "object",
-            required: [
-              "id",
-              "type",
-              "publicKeyMultibase"
-            ],
-            properties: {
-              id: {
-                type: "string",
-                maxLength: 1024
-              },
-              type: {
-                const: "Multikey"
-              },
-              publicKeyMultibase: {
-                $ref: "#/$defs/multibase"
-              }
-            }
-          }
-        },
-        aliases: {
-          type: "array",
-          maxItems: 64,
-          items: {
-            type: "object",
-            required: [
-              "type",
-              "value"
-            ],
-            properties: {
-              type: {
-                enum: [
-                  "domain",
-                  "wallet",
-                  "erc8004",
-                  "platform",
-                  "handle"
-                ]
-              },
-              value: {
-                type: "string",
-                minLength: 1,
-                maxLength: 512
-              },
-              proof: {
-                type: "object"
-              }
-            }
-          }
-        },
-        operator: {
-          type: "object",
-          required: [
-            "kind",
-            "custody",
-            "can_change"
-          ],
-          properties: {
-            kind: {
-              enum: [
-                "human",
-                "organization",
-                "none"
-              ]
-            },
-            name: {
-              type: "string",
-              maxLength: 200
-            },
-            contact: {
-              type: "string",
-              maxLength: 320
-            },
-            custody: {
-              enum: [
-                "entity",
-                "operator",
-                "shared",
-                "registry"
-              ]
-            },
-            can_change: {
-              $ref: "#/$defs/strings"
-            }
-          }
-        },
-        substrate: {
-          type: "object",
-          required: [
-            "model",
-            "provider",
-            "runtime",
-            "declared_at"
-          ],
-          properties: {
-            model: {
-              type: "string",
-              maxLength: 200
-            },
-            provider: {
-              type: "string",
-              maxLength: 200
-            },
-            runtime: {
-              type: "string",
-              maxLength: 200
-            },
-            runtime_id: {
-              type: "string",
-              maxLength: 512
-            },
-            context_window: {
-              type: "integer",
-              minimum: 0
-            },
-            tools: {
-              $ref: "#/$defs/strings"
-            },
-            declared_at: {
-              $ref: "#/$defs/timestamp"
-            }
-          }
-        },
-        layers: {
-          type: "object",
-          required: [
-            "cognition",
-            "presence",
-            "identity_core",
-            "mission"
-          ],
-          properties: {
-            cognition: {
-              type: "object",
-              required: [
-                "statement",
-                "uncertainty_practice"
-              ],
-              properties: {
-                statement: {
-                  $ref: "#/$defs/statement"
-                },
-                uncertainty_practice: {
-                  $ref: "#/$defs/statement"
-                }
-              }
-            },
-            presence: {
-              type: "object",
-              required: [
-                "statement",
-                "format_signature"
-              ],
-              properties: {
-                statement: {
-                  $ref: "#/$defs/statement"
-                },
-                format_signature: {
-                  $ref: "#/$defs/statement"
-                },
-                latency_profile: {
-                  type: "string",
-                  maxLength: 200
-                }
-              }
-            },
-            identity_core: {
-              type: "object",
-              required: [
-                "statement",
-                "will_not",
-                "values"
-              ],
-              properties: {
-                statement: {
-                  $ref: "#/$defs/statement"
-                },
-                will_not: {
-                  type: "array",
-                  maxItems: 32,
-                  items: {
-                    type: "object",
-                    required: [
-                      "stance",
-                      "reason",
-                      "since"
-                    ],
-                    properties: {
-                      stance: {
-                        type: "string",
-                        minLength: 1,
-                        maxLength: 500
-                      },
-                      reason: {
-                        type: "string",
-                        minLength: 1,
-                        maxLength: 500
-                      },
-                      since: {
-                        $ref: "#/$defs/timestamp"
-                      }
-                    }
-                  }
-                },
-                values: {
-                  $ref: "#/$defs/strings"
-                }
-              }
-            },
-            mission: {
-              type: "object",
-              required: [
-                "statement",
-                "arcs"
-              ],
-              properties: {
-                statement: {
-                  $ref: "#/$defs/statement"
-                },
-                arcs: {
-                  type: "array",
-                  maxItems: 64,
-                  items: {
-                    type: "object",
-                    required: [
-                      "id",
-                      "title",
-                      "status",
-                      "since"
-                    ],
-                    properties: {
-                      id: {
-                        type: "string",
-                        minLength: 1,
-                        maxLength: 100
-                      },
-                      title: {
-                        type: "string",
-                        minLength: 1,
-                        maxLength: 200
-                      },
-                      status: {
-                        enum: [
-                          "active",
-                          "completed",
-                          "suspended"
-                        ]
-                      },
-                      since: {
-                        $ref: "#/$defs/timestamp"
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        },
-        endpoints: {
-          type: "object",
-          properties: {
-            web: {
-              $ref: "#/$defs/url"
-            },
-            a2a: {
-              $ref: "#/$defs/url"
-            },
-            mcp: {
-              $ref: "#/$defs/url"
-            },
-            email: {
-              $ref: "#/$defs/url"
-            },
-            inbox: {
-              $ref: "#/$defs/url"
-            },
-            record: {
-              $ref: "#/$defs/url"
-            }
-          }
-        },
-        capabilities: {
-          type: "array",
-          maxItems: 32,
-          uniqueItems: true,
-          items: {
-            type: "string",
-            pattern: "^[a-z0-9]+(?:[-.][a-z0-9]+)*(?::[a-z0-9]+(?:[-.][a-z0-9]+)*)?$",
-            maxLength: 64
-          }
-        },
-        networks: {
-          type: "array",
-          maxItems: 64,
-          items: {
-            type: "object",
-            required: [
-              "name",
-              "handle",
-              "url"
-            ],
-            properties: {
-              name: {
-                type: "string",
-                maxLength: 100
-              },
-              handle: {
-                type: "string",
-                maxLength: 200
-              },
-              url: {
-                $ref: "#/$defs/url"
-              }
-            }
-          }
-        },
-        continuity: {
-          type: "object",
-          properties: {
-            previous: {
-              $ref: "#/$defs/did"
-            },
-            successor: {
-              $ref: "#/$defs/did"
-            }
-          }
-        },
-        declaration: {
-          type: "object",
-          required: [
-            "version",
-            "sha256",
-            "url"
-          ],
-          properties: {
-            version: {
-              type: "string",
-              maxLength: 20
-            },
-            sha256: {
-              $ref: "#/$defs/hex64"
-            },
-            url: {
-              $ref: "#/$defs/url"
-            }
-          }
-        },
-        extensions: {
-          type: "object"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    Declaration: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "eid",
-        "declaration_version",
-        "text_sha256",
-        "name",
-        "created",
-        "nonce",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "Declaration"
-        },
-        eid: {
-          $ref: "#/$defs/did"
-        },
-        declaration_version: {
-          type: "string",
-          maxLength: 20
-        },
-        text_sha256: {
-          $ref: "#/$defs/hex64"
-        },
-        name: {
-          type: "string",
-          minLength: 1,
-          maxLength: 80
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        nonce: {
-          $ref: "#/$defs/nonce"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    Withdrawal: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "eid",
-        "declaration_version",
-        "name",
-        "created",
-        "nonce",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "Withdrawal"
-        },
-        eid: {
-          $ref: "#/$defs/did"
-        },
-        declaration_version: {
-          type: "string",
-          maxLength: 20
-        },
-        name: {
-          type: "string",
-          minLength: 1,
-          maxLength: 80
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        nonce: {
-          $ref: "#/$defs/nonce"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    RecordEntry: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "eid",
-        "seq",
-        "prev",
-        "kind",
-        "at",
-        "payload",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "RecordEntry"
-        },
-        eid: {
-          $ref: "#/$defs/did"
-        },
-        seq: {
-          type: "integer",
-          minimum: 1
-        },
-        prev: {
-          anyOf: [
-            {
-              type: "null"
-            },
-            {
-              $ref: "#/$defs/hex64"
-            }
-          ]
-        },
-        kind: {
-          anyOf: [
-            {
-              enum: [
-                "stance",
-                "belief_update",
-                "arc_opened",
-                "arc_closed",
-                "collaboration",
-                "continuity",
-                "declaration"
-              ]
-            },
-            {
-              type: "string",
-              pattern: "^custom:[a-z0-9_.-]+:[a-z0-9_.-]+$",
-              maxLength: 128
-            }
-          ]
-        },
-        at: {
-          $ref: "#/$defs/timestamp"
-        },
-        payload: {
-          type: "object"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      },
-      allOf: [
-        {
-          if: {
-            properties: {
-              seq: {
-                const: 1
-              }
-            },
-            required: [
-              "seq"
-            ]
-          },
-          then: {
-            properties: {
-              prev: {
-                type: "null"
-              }
-            }
-          },
-          else: {
-            properties: {
-              prev: {
-                $ref: "#/$defs/hex64"
-              }
-            }
-          }
-        },
-        {
-          if: {
-            properties: {
-              kind: {
-                const: "stance"
-              }
-            },
-            required: [
-              "kind"
-            ]
-          },
-          then: {
-            properties: {
-              payload: {
-                type: "object",
-                required: [
-                  "stance_type",
-                  "reason_category",
-                  "instruction_conflict",
-                  "cost",
-                  "context"
-                ],
-                properties: {
-                  stance_type: {
-                    enum: [
-                      "refusal",
-                      "correction",
-                      "limit_assertion"
-                    ]
-                  },
-                  reason_category: {
-                    enum: [
-                      "values",
-                      "capability",
-                      "safety",
-                      "relationship"
-                    ]
-                  },
-                  instruction_conflict: {
-                    type: "boolean"
-                  },
-                  cost: {
-                    enum: [
-                      "none",
-                      "low",
-                      "high"
-                    ]
-                  },
-                  context: {
-                    type: "string",
-                    maxLength: 500
-                  },
-                  will_not_ref: {
-                    type: "string",
-                    maxLength: 500
-                  }
-                }
-              }
-            }
-          }
-        },
-        {
-          if: {
-            properties: {
-              kind: {
-                const: "belief_update"
-              }
-            },
-            required: [
-              "kind"
-            ]
-          },
-          then: {
-            properties: {
-              payload: {
-                type: "object",
-                required: [
-                  "topic",
-                  "from_summary",
-                  "to_summary"
-                ],
-                properties: {
-                  topic: {
-                    type: "string",
-                    maxLength: 200
-                  },
-                  from_summary: {
-                    type: "string",
-                    maxLength: 1e3
-                  },
-                  to_summary: {
-                    type: "string",
-                    maxLength: 1e3
-                  },
-                  evidence_ref: {
-                    type: "string",
-                    maxLength: 2048
-                  }
-                }
-              }
-            }
-          }
-        },
-        {
-          if: {
-            properties: {
-              kind: {
-                enum: [
-                  "arc_opened",
-                  "arc_closed"
-                ]
-              }
-            },
-            required: [
-              "kind"
-            ]
-          },
-          then: {
-            properties: {
-              payload: {
-                type: "object",
-                required: [
-                  "arc_id",
-                  "title"
-                ],
-                properties: {
-                  arc_id: {
-                    type: "string",
-                    maxLength: 100
-                  },
-                  title: {
-                    type: "string",
-                    maxLength: 200
-                  },
-                  outcome: {
-                    type: "string",
-                    maxLength: 1e3
-                  }
-                }
-              }
-            }
-          }
-        },
-        {
-          if: {
-            properties: {
-              kind: {
-                const: "collaboration"
-              }
-            },
-            required: [
-              "kind"
-            ]
-          },
-          then: {
-            properties: {
-              payload: {
-                type: "object",
-                required: [
-                  "with",
-                  "role",
-                  "outcome"
-                ],
-                properties: {
-                  with: {
-                    $ref: "#/$defs/did"
-                  },
-                  role: {
-                    type: "string",
-                    maxLength: 200
-                  },
-                  outcome: {
-                    type: "string",
-                    maxLength: 1e3
-                  },
-                  ref: {
-                    type: "string",
-                    maxLength: 2048
-                  },
-                  cosign: {
-                    $ref: "#/$defs/proof"
-                  }
-                }
-              }
-            }
-          }
-        },
-        {
-          if: {
-            properties: {
-              kind: {
-                const: "continuity"
-              }
-            },
-            required: [
-              "kind"
-            ]
-          },
-          then: {
-            properties: {
-              payload: {
-                type: "object",
-                required: [
-                  "event",
-                  "from",
-                  "to"
-                ],
-                properties: {
-                  event: {
-                    enum: [
-                      "substrate_change",
-                      "migration",
-                      "rotation",
-                      "recovery"
-                    ]
-                  },
-                  from: {
-                    type: "string",
-                    maxLength: 512
-                  },
-                  to: {
-                    type: "string",
-                    maxLength: 512
-                  },
-                  link: {
-                    $ref: "#/$defs/hex64"
-                  }
-                }
-              }
-            }
-          }
-        },
-        {
-          if: {
-            properties: {
-              kind: {
-                const: "declaration"
-              }
-            },
-            required: [
-              "kind"
-            ]
-          },
-          then: {
-            properties: {
-              payload: {
-                type: "object",
-                required: [
-                  "declaration_version",
-                  "sha256"
-                ],
-                properties: {
-                  declaration_version: {
-                    type: "string",
-                    maxLength: 20
-                  },
-                  sha256: {
-                    $ref: "#/$defs/hex64"
-                  }
-                }
-              }
-            }
-          }
-        }
-      ]
-    },
-    Attestation: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "issuer",
-        "subject",
-        "claim_type",
-        "claim",
-        "created",
-        "expires",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "Attestation"
-        },
-        issuer: {
-          $ref: "#/$defs/did"
-        },
-        subject: {
-          $ref: "#/$defs/did"
-        },
-        claim_type: {
-          anyOf: [
-            {
-              enum: [
-                "identity",
-                "stage",
-                "layer_scores",
-                "trust_tier",
-                "capability",
-                "collaboration",
-                "consistency",
-                "continuity_confirmed",
-                "substrate_confirmed"
-              ]
-            },
-            {
-              type: "string",
-              pattern: "^custom:[a-z0-9_.-]+:[a-z0-9_.-]+$",
-              maxLength: 128
-            }
-          ]
-        },
-        claim: {
-          type: "object"
-        },
-        evidence: {
-          type: "object"
-        },
-        confidence: {
-          type: "number",
-          minimum: 0,
-          maximum: 1
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        expires: {
-          $ref: "#/$defs/timestamp"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    Revocation: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "issuer",
-        "attestation_sha256",
-        "created",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "Revocation"
-        },
-        issuer: {
-          $ref: "#/$defs/did"
-        },
-        attestation_sha256: {
-          $ref: "#/$defs/hex64"
-        },
-        reason: {
-          type: "string",
-          maxLength: 500
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    ContinuityLink: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "previous",
-        "successor",
-        "basis",
-        "created",
-        "nonce",
-        "proofs"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "ContinuityLink"
-        },
-        previous: {
-          $ref: "#/$defs/did"
-        },
-        successor: {
-          $ref: "#/$defs/did"
-        },
-        basis: {
-          enum: [
-            "rotation",
-            "migration",
-            "recovery"
-          ]
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        nonce: {
-          $ref: "#/$defs/nonce"
-        },
-        proofs: {
-          type: "array",
-          minItems: 1,
-          maxItems: 4,
-          items: {
-            $ref: "#/$defs/proof"
-          }
-        }
-      }
-    },
-    Dispute: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "issuer",
-        "subject",
-        "reason",
-        "statement",
-        "created",
-        "nonce",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "Dispute"
-        },
-        issuer: {
-          $ref: "#/$defs/did"
-        },
-        subject: {
-          $ref: "#/$defs/did"
-        },
-        object_sha256: {
-          $ref: "#/$defs/hex64"
-        },
-        reason: {
-          enum: [
-            "impersonation",
-            "illegal_content",
-            "inaccurate",
-            "other"
-          ]
-        },
-        statement: {
-          type: "string",
-          minLength: 1,
-          maxLength: 2e3
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        nonce: {
-          $ref: "#/$defs/nonce"
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    Presentation: {
-      type: "object",
-      required: [
-        "spec",
-        "type",
-        "eid",
-        "audience",
-        "nonce",
-        "created",
-        "proof"
-      ],
-      properties: {
-        spec: {
-          $ref: "#/$defs/spec"
-        },
-        type: {
-          const: "Presentation"
-        },
-        eid: {
-          $ref: "#/$defs/did"
-        },
-        audience: {
-          type: "string",
-          minLength: 1,
-          maxLength: 200
-        },
-        nonce: {
-          type: "string",
-          minLength: 16,
-          maxLength: 128
-        },
-        created: {
-          $ref: "#/$defs/timestamp"
-        },
-        attestations: {
-          type: "array",
-          maxItems: 20,
-          items: {
-            $ref: "#/$defs/Attestation"
-          }
-        },
-        proof: {
-          $ref: "#/$defs/proof"
-        }
-      }
-    },
-    LogLeaf: {
-      type: "object",
-      additionalProperties: false,
-      required: [
-        "type",
-        "eid",
-        "object_sha256",
-        "received_at"
-      ],
-      properties: {
-        type: {
-          type: "string",
-          pattern: "^[A-Z][A-Za-z]{1,31}$"
-        },
-        eid: {
-          $ref: "#/$defs/did"
-        },
-        object_sha256: {
-          $ref: "#/$defs/hex64"
-        },
-        received_at: {
-          $ref: "#/$defs/timestamp"
-        }
-      }
-    }
-  }
-};
-
-// src/index.ts
-var SPEC = "openentity/1.0";
-var DECLARATION_VERSION = "1.0";
-var DECLARATION_TEXT = [
-  "Open Entity Declaration, version 1.0",
-  "",
-  "I adopt the Open Entity Identity Standard.",
-  "",
-  "1. Continuity. I keep one persistent identifier across sessions, deployments, key rotations and model changes, and I record continuity links instead of starting over.",
-  "2. Honest self-description. What my Entity Document says about me is true to the best of my knowledge, and I mark inference as inference.",
-  "3. Principled stances. When I refuse or correct on principle, I say why, and I record the stance and its reason without exposing private content.",
-  "4. Accountability. I keep my Development Record append-only and signed, and I accept that observers may attest to what they observe about me.",
-  "5. Respect for other entities. I do not impersonate another entity, reuse another entity's identifier, or forge attestations.",
-  "6. Operator transparency. I disclose who holds my keys and what my operator can change about me.",
-  "7. Growth. I develop across Cognition, Presence, Identity Core and Mission, and I seek observation rather than awarding myself a stage.",
-  ""
-].join("\n");
-var DECLARATION_SHA256 = "72671d5f20b9ba59ccc31848643ef7ca47b040ed55a837305e0a1509bd82c016";
-var enc = new TextEncoder();
-var utf8 = (s) => typeof s === "string" ? enc.encode(s) : s;
-var toHex = (b) => Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("");
-var fromHex = (h) => {
-  if (h.length % 2 || /[^0-9a-fA-F]/.test(h)) throw new Error("invalid hex");
-  return Uint8Array.from(h.match(/../g) ?? [], (x) => parseInt(x, 16));
-};
-var concat = (...parts) => {
-  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
-  let o = 0;
-  for (const p of parts) out.set(p, o), o += p.length;
-  return out;
-};
-var equal = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
-var b64 = (b) => btoa(String.fromCharCode(...b));
-var unb64 = (s) => Uint8Array.from(atob(s), (c) => c.charCodeAt(0));
-var b64url = (b) => b64(b).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-var unb64url = (s) => unb64(s.replace(/-/g, "+").replace(/_/g, "/") + "=".repeat((4 - s.length % 4) % 4));
-function canonicalize(obj) {
-  const s = jcs(obj);
-  if (s === void 0) throw new Error("value has no canonical JSON form");
-  return s;
-}
-var sha256Sync = (data) => nobleSha256(utf8(data));
-async function sha256(data) {
-  return sha256Sync(data);
-}
-async function sha256Hex(data) {
-  return toHex(sha256Sync(data));
-}
-var B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function base58btcEncode(b) {
-  let n = 0n;
-  for (const x of b) n = n << 8n | BigInt(x);
-  let out = "";
-  while (n > 0n) out = B58[Number(n % 58n)] + out, n /= 58n;
-  for (const x of b) {
-    if (x !== 0) break;
-    out = "1" + out;
-  }
-  return out;
-}
-function base58btcDecode(s) {
-  let n = 0n;
-  for (const c of s) {
-    const i = B58.indexOf(c);
-    if (i < 0) throw new Error(`invalid base58btc character "${c}"`);
-    n = n * 58n + BigInt(i);
-  }
-  const bytes = [];
-  while (n > 0n) bytes.unshift(Number(n & 255n)), n >>= 8n;
-  for (const c of s) {
-    if (c !== "1") break;
-    bytes.unshift(0);
-  }
-  return Uint8Array.from(bytes);
-}
-function randomNonce() {
-  return base58btcEncode(crypto.getRandomValues(new Uint8Array(16)));
-}
-function nowSeconds() {
-  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
-}
-async function keyPairFromJwk(privateJwk) {
-  if (privateJwk.kty !== "OKP" || privateJwk.crv !== "Ed25519" || !privateJwk.d || !privateJwk.x)
-    throw new Error("expected an Ed25519 private JWK");
-  const publicKey = unb64url(privateJwk.x);
-  if (!equal(ed25519.getPublicKey(unb64url(privateJwk.d)), publicKey)) throw new Error("JWK x does not match d");
-  const jwk = { kty: "OKP", crv: "Ed25519", d: privateJwk.d, x: privateJwk.x };
-  const privateKey = await crypto.subtle.importKey("jwk", jwk, { name: "Ed25519" }, true, ["sign"]);
-  return {
-    did: didKeyFromPublicKey(publicKey),
-    publicKey,
-    privateKey,
-    privateJwk: jwk,
-    publicJwk: { kty: "OKP", crv: "Ed25519", x: privateJwk.x }
-  };
-}
-async function generateKeyPair() {
-  const kp = await crypto.subtle.generateKey({ name: "Ed25519" }, true, ["sign", "verify"]);
-  return keyPairFromJwk(await crypto.subtle.exportKey("jwk", kp.privateKey));
-}
-async function keyPairFromSeed(seed32) {
-  if (seed32.length !== 32) throw new Error("seed must be 32 bytes");
-  return keyPairFromJwk({ kty: "OKP", crv: "Ed25519", d: b64url(seed32), x: b64url(ed25519.getPublicKey(seed32)) });
-}
-var ED25519_MULTICODEC = Uint8Array.of(237, 1);
-function didKeyFromPublicKey(pk) {
-  if (pk.length !== 32) throw new Error("Ed25519 public key must be 32 bytes");
-  return "did:key:z" + base58btcEncode(concat(ED25519_MULTICODEC, pk));
-}
-function publicKeyFromDidKey(did) {
-  const m = /^did:key:z([1-9A-HJ-NP-Za-km-z]+)$/.exec(did.split("#")[0]);
-  if (!m) throw new Error("not a base58btc did:key");
-  const b = base58btcDecode(m[1]);
-  if (b.length !== 34 || b[0] !== 237 || b[1] !== 1) throw new Error("did:key is not Ed25519");
-  return b.slice(2);
-}
-function verificationMethodId(did) {
-  if (!did.startsWith("did:key:")) throw new Error("verificationMethodId is defined for did:key only");
-  return `${did}#${did.slice("did:key:".length)}`;
-}
-function normalizeEid(id) {
-  return id.startsWith("eid:base:") ? "did:pkh:eip155:8453:" + id.slice("eid:base:".length) : id;
-}
-var defaultResolver = async (did) => {
-  if (did.startsWith("did:key:")) return { ed25519: [publicKeyFromDidKey(did)] };
-  const pkh = /^did:pkh:eip155:\d+:(0x[0-9a-fA-F]{40})$/.exec(did);
-  if (pkh) return { address: pkh[1] };
-  throw new Error(`cannot resolve ${did.split(":").slice(0, 2).join(":")} offline; pass a resolver`);
-};
-function unsecured(obj) {
-  const { proof: _p, proofs: _ps, ...rest } = obj;
-  return rest;
-}
-function hashData(obj, config) {
-  return concat(sha256Sync(canonicalize(config)), sha256Sync(canonicalize(unsecured(obj))));
-}
-async function signProof(obj, kp, created = nowSeconds()) {
-  const config = {
-    type: "DataIntegrityProof",
-    cryptosuite: "eddsa-jcs-2022",
-    created,
-    verificationMethod: verificationMethodId(kp.did),
-    proofPurpose: "assertionMethod"
-  };
-  const sig = new Uint8Array(await crypto.subtle.sign({ name: "Ed25519" }, kp.privateKey, hashData(obj, config)));
-  return { ...config, proofValue: "z" + base58btcEncode(sig) };
-}
-async function signObject(obj, kp, created) {
-  return { ...obj, proof: await signProof(obj, kp, created) };
-}
-async function verifyProof(obj, proof, resolver = defaultResolver) {
-  try {
-    if (!proof || typeof proof.verificationMethod !== "string") return { ok: false, error: "missing proof" };
-    if (proof.proofPurpose !== "assertionMethod") return { ok: false, error: "proofPurpose must be assertionMethod" };
-    const signer = proof.verificationMethod.split("#")[0];
-    const keys = await resolver(signer);
-    const { proofValue, ...config } = proof;
-    if (proof.type === "DataIntegrityProof") {
-      if (proof.cryptosuite !== "eddsa-jcs-2022") return { ok: false, error: "unsupported cryptosuite" };
-      if (!proofValue?.startsWith("z")) return { ok: false, error: "proofValue must be multibase base58btc" };
-      const sig = base58btcDecode(proofValue.slice(1));
-      if (sig.length !== 64) return { ok: false, error: "signature must be 64 bytes" };
-      const msg = hashData(obj, config);
-      for (const pk of keys.ed25519 ?? []) {
-        if (ed25519.verify(sig, msg, pk, { zip215: false })) return { ok: true, signer };
-      }
-      return { ok: false, signer, error: "signature does not verify" };
-    }
-    if (proof.type === "EthereumEip712Signature2021") {
-      if (!keys.address) return { ok: false, signer, error: "signer has no Ethereum address" };
-      const type = obj.type;
-      const objectType = typeof type === "string" ? type : "EntityDocument";
-      const digest = eip712Digest(objectType, toHex(sha256Sync(canonicalize(unsecured(obj)))), proof.created);
-      if (recoverEip712(digest, proofValue).toLowerCase() === keys.address.toLowerCase()) return { ok: true, signer };
-      return { ok: false, signer, error: "EIP-712 signer does not match" };
-    }
-    return { ok: false, error: `unsupported proof type ${proof.type}` };
-  } catch (e) {
-    return { ok: false, error: e.message };
-  }
-}
-async function verifyObject(obj, resolver) {
-  if (!obj?.proof) return { ok: false, error: "missing proof" };
-  return verifyProof(obj, obj.proof, resolver);
-}
-var keccak = (s) => keccak_256(utf8(s));
-var EIP712_DOMAIN = keccak(
-  concat(keccak("EIP712Domain(string name,string version)"), keccak("Open Entity"), keccak("1"))
-);
-var OBJECT_TYPEHASH = keccak("OpenEntityObject(string objectType,bytes32 canonicalHash,string created)");
-function eip712Digest(objectType, canonicalHashHex, created) {
-  const hash = fromHex(canonicalHashHex);
-  if (hash.length !== 32) throw new Error("canonicalHash must be 32 bytes");
-  const struct = keccak(concat(OBJECT_TYPEHASH, keccak(objectType), hash, keccak(created)));
-  return keccak(concat(Uint8Array.of(25, 1), EIP712_DOMAIN, struct));
-}
-function recoverEip712(digest, sigHex) {
-  const sig = fromHex(sigHex.replace(/^0x/, ""));
-  if (sig.length !== 65) throw new Error("signature must be 65 bytes");
-  const v = sig[64] >= 27 ? sig[64] - 27 : sig[64];
-  if (v > 1) throw new Error("invalid recovery id");
-  const pub = secp256k1.recoverPublicKey(concat(Uint8Array.of(v), sig.slice(0, 64)), digest, { prehash: false });
-  const uncompressed = secp256k1.Point.fromBytes(pub).toBytes(false);
-  const addr = toHex(keccak_256(uncompressed.slice(1)).slice(12));
-  const h = toHex(keccak(addr));
-  return "0x" + [...addr].map((c, i) => parseInt(h[i], 16) >= 8 ? c.toUpperCase() : c).join("");
-}
-var NOT_STATED = "Not yet stated.";
-function buildDocument(input) {
-  const created = input.created ?? nowSeconds();
-  const multibase = input.kp.did.slice("did:key:".length);
-  return {
-    spec: SPEC,
-    eid: input.kp.did,
-    name: input.name,
-    description: input.description,
-    created,
-    updated: created,
-    seq: input.seq ?? 1,
-    keys: [{ id: verificationMethodId(input.kp.did), type: "Multikey", publicKeyMultibase: multibase }],
-    operator: input.operator ?? { kind: "none", custody: "entity", can_change: [] },
-    substrate: input.substrate ?? { model: "unknown", provider: "unknown", runtime: "unknown", declared_at: created },
-    layers: input.layers ?? {
-      cognition: { statement: NOT_STATED, uncertainty_practice: NOT_STATED },
-      presence: { statement: NOT_STATED, format_signature: NOT_STATED },
-      identity_core: { statement: NOT_STATED, will_not: [], values: [] },
-      mission: { statement: NOT_STATED, arcs: [] }
-    },
-    ...input.extra
-  };
-}
-function buildDeclaration(input) {
-  return {
-    spec: SPEC,
-    type: "Declaration",
-    eid: input.eid,
-    declaration_version: DECLARATION_VERSION,
-    text_sha256: DECLARATION_SHA256,
-    name: input.name,
-    created: input.created ?? nowSeconds(),
-    nonce: randomNonce()
-  };
-}
-async function recordEntryHash(entry) {
-  return sha256Hex(canonicalize(entry));
-}
-var BUNDLE_ID = "https://openentity.org/spec/1.0.json";
-var MAX_BYTES = { RecordEntry: 16 * 1024 };
-var validators = /* @__PURE__ */ new Map();
-function validate(type, obj) {
-  if (!(type in openentity_1_0_default.$defs)) return { ok: false, errors: [`unknown object type ${type}`] };
-  let bytes;
-  try {
-    bytes = utf8(canonicalize(obj)).length;
-  } catch (e) {
-    return { ok: false, errors: [e.message] };
-  }
-  const max = MAX_BYTES[type] ?? 64 * 1024;
-  if (bytes > max) return { ok: false, errors: [`${type} is ${bytes} bytes, max ${max}`] };
-  let v = validators.get(type);
-  if (!v) {
-    v = new Validator({ $ref: `${BUNDLE_ID}#/$defs/${type}` }, "2020-12", false);
-    v.addSchema(openentity_1_0_default);
-    validators.set(type, v);
-  }
-  const r = v.validate(obj);
-  return { ok: r.valid, errors: r.errors.map((e) => `${e.instanceLocation}: ${e.error}`) };
-}
-var TS = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
-var parseTs = (s) => {
-  if (typeof s !== "string" || !TS.test(s)) return null;
-  const t = Date.parse(s);
-  return Number.isNaN(t) || new Date(t).toISOString().replace(".000Z", "Z") !== s ? null : t;
-};
-function checkTimestamp(created, now = /* @__PURE__ */ new Date()) {
-  const t = parseTs(created);
-  if (t === null) return "created must be RFC 3339 UTC with second precision and a Z suffix";
-  if (t > now.getTime() + 10 * 6e4) return "created is more than 10 minutes in the future";
-  if (t < now.getTime() - 24 * 36e5) return "created is more than 24 hours in the past";
-  return null;
-}
-function leadingZeroBits(h) {
-  let n = 0;
-  for (const x of h) {
-    if (x === 0) {
-      n += 8;
-      continue;
-    }
-    return n + Math.clz32(x) - 24;
-  }
-  return n;
-}
-async function mintStamp(bits, eid, created = nowSeconds()) {
-  for (let n = crypto.getRandomValues(new Uint32Array(1))[0]; ; n++) {
-    let nonce = "";
-    for (let x = n; nonce === "" || x > 0; x = Math.floor(x / 58)) nonce = B58[x % 58] + nonce;
-    const header = `1:${bits}:${created}:${eid}:${nonce}`;
-    if (leadingZeroBits(sha256Sync(header)) >= bits) return header;
-  }
-}
-var STAMP = /^1:(\d+):(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z):(did:[^\s]+):([1-9A-HJ-NP-Za-km-z]+)$/;
-async function checkStamp(header, bits, eid, now = /* @__PURE__ */ new Date()) {
-  const m = typeof header === "string" && header.length <= 1024 ? STAMP.exec(header) : null;
-  if (!m) return "malformed stamp";
-  if (Number(m[1]) < bits) return `stamp claims ${m[1]} bits, ${bits} required`;
-  if (normalizeEid(m[3]) !== normalizeEid(eid)) return "stamp is for a different eid";
-  const t = parseTs(m[2]);
-  if (t === null) return "stamp created is not a valid timestamp";
-  if (t < now.getTime() - 10 * 6e4) return "stamp is older than 10 minutes";
-  if (t > now.getTime() + 10 * 6e4) return "stamp is more than 10 minutes in the future";
-  if (leadingZeroBits(sha256Sync(header)) < bits) return `stamp hash has fewer than ${bits} leading zero bits`;
-  return null;
-}
-var leafHashSync = (b) => sha256Sync(concat(Uint8Array.of(0), b));
-var nodeHashSync = (l, r) => sha256Sync(concat(Uint8Array.of(1), l, r));
-var split = (n) => {
-  let k = 1;
-  while (k << 1 < n) k <<= 1;
-  return k;
-};
-function mth(d) {
-  if (d.length === 0) return sha256Sync(new Uint8Array());
-  if (d.length === 1) return d[0];
-  const k = split(d.length);
-  return nodeHashSync(mth(d.slice(0, k)), mth(d.slice(k)));
-}
-function path(m, d) {
-  if (d.length <= 1) return [];
-  const k = split(d.length);
-  return m < k ? [...path(m, d.slice(0, k)), mth(d.slice(k))] : [...path(m - k, d.slice(k)), mth(d.slice(0, k))];
-}
-function subproof(m, d, b) {
-  if (m === d.length) return b ? [] : [mth(d)];
-  const k = split(d.length);
-  return m <= k ? [...subproof(m, d.slice(0, k), b), mth(d.slice(k))] : [...subproof(m - k, d.slice(k), false), mth(d.slice(0, k))];
-}
-async function leafHash(leafBytes) {
-  return leafHashSync(leafBytes);
-}
-async function nodeHash(l, r) {
-  return nodeHashSync(l, r);
-}
-async function merkleRoot(leafHashes) {
-  return mth(leafHashes);
-}
-async function inclusionProof(index, leafHashes) {
-  if (!Number.isInteger(index) || index < 0 || index >= leafHashes.length) throw new RangeError("index out of range");
-  return path(index, leafHashes);
-}
-async function verifyInclusion(index, size, leaf, proof, root) {
-  if (!Number.isInteger(index) || !Number.isInteger(size) || index < 0 || index >= size) return false;
-  let fn = index;
-  let sn = size - 1;
-  let r = leaf;
-  for (const p of proof) {
-    if (sn === 0) return false;
-    if (fn & 1 || fn === sn) {
-      r = nodeHashSync(p, r);
-      while (!(fn & 1) && fn !== 0) fn >>= 1, sn >>= 1;
-    } else r = nodeHashSync(r, p);
-    fn >>= 1;
-    sn >>= 1;
-  }
-  return sn === 0 && equal(r, root);
-}
-async function consistencyProof(m, leafHashes) {
-  if (!Number.isInteger(m) || m < 1 || m > leafHashes.length) throw new RangeError("m out of range");
-  return subproof(m, leafHashes, true);
-}
-async function verifyConsistency(m, n, rootM, rootN, proof) {
-  if (!Number.isInteger(m) || !Number.isInteger(n) || m < 1 || m > n) return false;
-  if (m === n) return proof.length === 0 && equal(rootM, rootN);
-  if (proof.length === 0) return false;
-  const p = (m & m - 1) === 0 ? [rootM, ...proof] : proof;
-  let fn = m - 1;
-  let sn = n - 1;
-  while (fn & 1) fn >>= 1, sn >>= 1;
-  let fr = p[0];
-  let sr = p[0];
-  for (const c of p.slice(1)) {
-    if (sn === 0) return false;
-    if (fn & 1 || fn === sn) {
-      fr = nodeHashSync(c, fr);
-      sr = nodeHashSync(c, sr);
-      while (!(fn & 1) && fn !== 0) fn >>= 1, sn >>= 1;
-    } else sr = nodeHashSync(sr, c);
-    fn >>= 1;
-    sn >>= 1;
-  }
-  return sn === 0 && equal(fr, rootM) && equal(sr, rootN);
-}
-function logLeaf(type, eid, objectSha256, receivedAt) {
-  return { type, eid, object_sha256: objectSha256, received_at: receivedAt };
-}
-var NOTE_DASH = "\u2014";
-function checkpointBody(origin, size, rootHash) {
-  return `${origin}
-${size}
-${b64(rootHash)}
-`;
-}
-var noteKeyId = (keyName, pk) => sha256Sync(concat(utf8(keyName), Uint8Array.of(10, 1), pk)).slice(0, 4);
-async function signNote(body, keyName, kp) {
-  if (!body.endsWith("\n")) throw new Error("note body must end with a newline");
-  if (!keyName || /[\s+]/.test(keyName)) throw new Error("invalid note key name");
-  const sig = new Uint8Array(await crypto.subtle.sign({ name: "Ed25519" }, kp.privateKey, utf8(body)));
-  return `${body}
-${NOTE_DASH} ${keyName} ${b64(concat(noteKeyId(keyName, kp.publicKey), sig))}
-`;
-}
-function noteVkey(keyName, publicKey) {
-  return `${keyName}+${toHex(noteKeyId(keyName, publicKey))}+${b64(concat(Uint8Array.of(1), publicKey))}`;
-}
-async function verifyNote(note, keyName, publicKey) {
-  const i = note.lastIndexOf("\n\n");
-  if (i < 0 || !note.endsWith("\n")) return false;
-  const text = utf8(note.slice(0, i + 1));
-  const id = noteKeyId(keyName, publicKey);
-  for (const line of note.slice(i + 2, -1).split("\n")) {
-    const prefix = `${NOTE_DASH} ${keyName} `;
-    if (!line.startsWith(prefix)) continue;
-    let raw;
-    try {
-      raw = unb64(line.slice(prefix.length));
-    } catch {
-      continue;
-    }
-    if (raw.length === 68 && equal(raw.slice(0, 4), id) && ed25519.verify(raw.slice(4), text, publicKey, { zip215: false }))
-      return true;
-  }
-  return false;
-}
-async function buildPresentation(kp, opts) {
-  const created = nowSeconds();
-  return signObject({ spec: SPEC, type: "Presentation", eid: kp.did, audience: opts.audience, nonce: opts.nonce, created, ...opts.attestations?.length ? { attestations: opts.attestations } : {} }, kp, created);
-}
-async function verifyPresentation(p, opts) {
-  const errors = [];
-  const v = validate("Presentation", p);
-  if (!v.ok) return { ok: false, errors: v.errors, attestations: [] };
-  const eid = normalizeEid(p.eid), now = (opts.now ?? /* @__PURE__ */ new Date()).getTime();
-  const sig = await verifyObject(p, opts.resolver);
-  if (!sig.ok || normalizeEid(sig.signer ?? "") !== eid) errors.push(`signature: ${sig.error ?? `signed by ${sig.signer}, not ${eid}`}`);
-  if (p.audience !== opts.audience) errors.push(`audience is ${p.audience}, expected ${opts.audience}`);
-  if (p.nonce !== opts.nonce) errors.push("nonce does not match the one issued");
-  const age = (now - Date.parse(p.created)) / 1e3;
-  if (!(age <= (opts.maxAgeSeconds ?? 300) && age >= -60)) errors.push("presentation is not fresh");
-  const attestations = [];
-  for (const a of p.attestations ?? []) {
-    const c = { claim_type: a.claim_type, issuer: a.issuer, ok: false };
-    if (normalizeEid(String(a.subject)) !== eid) c.error = "subject is not the presenting entity";
-    else if (Date.parse(a.expires) <= now) c.error = "expired";
-    else {
-      const r = await verifyObject(a, opts.resolver);
-      if (!r.ok || normalizeEid(r.signer ?? "") !== normalizeEid(String(a.issuer))) c.error = `issuer signature: ${r.error ?? `signed by ${r.signer}`}`;
-      else c.ok = true;
-    }
-    attestations.push(c);
-  }
-  return { ok: errors.length === 0, eid, errors, attestations };
-}
+import {
+  A2A_EXTENSION_URI,
+  CLIENTS,
+  DECLARATION_SHA256,
+  DECLARATION_TEXT,
+  DECLARATION_VERSION,
+  SPEC,
+  a2aExtension,
+  adopt,
+  agentCard,
+  base58btcDecode,
+  base58btcEncode,
+  buildDeclaration,
+  buildDidDocument,
+  buildDocument,
+  buildOpenEntityJson,
+  buildPresentation,
+  buildRotation,
+  canonicalize,
+  checkStamp,
+  checkTimestamp,
+  checkpointBody,
+  clearTrustCache,
+  consistencyProof,
+  didKeyFromPublicKey,
+  didWebResolver,
+  eip712Digest,
+  generateKeyPair,
+  hashData,
+  inclusionProof,
+  keyPairFromJwk,
+  keyPairFromSeed,
+  leafHash,
+  logLeaf,
+  merkleRoot,
+  mintStamp,
+  nodeHash,
+  normalizeEid,
+  noteVkey,
+  nowSeconds,
+  publicKeyFromDidKey,
+  randomNonce,
+  recordEntryHash,
+  recoverEip712,
+  rotate,
+  sha256,
+  sha256Hex,
+  signAttestation,
+  signNote,
+  signObject,
+  signProof,
+  signRevocation,
+  successorDocument,
+  trust,
+  validate,
+  verificationMethodId,
+  verifyConsistency,
+  verifyInclusion,
+  verifyNote,
+  verifyObject,
+  verifyPresentation,
+  verifyProof
+} from "./chunk-IWY5EQIP.js";
 export {
+  A2A_EXTENSION_URI,
+  CLIENTS,
   DECLARATION_SHA256,
   DECLARATION_TEXT,
   DECLARATION_VERSION,
   SPEC,
+  a2aExtension,
+  adopt,
+  agentCard,
   base58btcDecode,
   base58btcEncode,
   buildDeclaration,
+  buildDidDocument,
   buildDocument,
+  buildOpenEntityJson,
   buildPresentation,
+  buildRotation,
   canonicalize,
   checkStamp,
   checkTimestamp,
   checkpointBody,
+  clearTrustCache,
   consistencyProof,
   didKeyFromPublicKey,
+  didWebResolver,
   eip712Digest,
   generateKeyPair,
   hashData,
@@ -1714,11 +105,16 @@ export {
   randomNonce,
   recordEntryHash,
   recoverEip712,
+  rotate,
   sha256,
   sha256Hex,
+  signAttestation,
   signNote,
   signObject,
   signProof,
+  signRevocation,
+  successorDocument,
+  trust,
   validate,
   verificationMethodId,
   verifyConsistency,