@interop/zcap 9.0.3 → 10.1.0

package/README.md

@@ -1,6 +1,6 @@
 # zcap _(@interop/zcap)_
 
-[![Node.js CI](https://github.com/interop-alliance/zcap/workflows/CI/badge.svg)](https://github.com/interop-alliance/zcap/actions?query=workflow%3A%22CI%22)
+[![CI](https://github.com/interop-alliance/zcap/workflows/CI/badge.svg)](https://github.com/interop-alliance/zcap/actions?query=workflow%3ACI)
 [![NPM Version](https://img.shields.io/npm/v/@interop/zcap.svg)](https://npm.im/@interop/zcap)
 
 > JavaScript reference implementation for

package/lib/CapabilityDelegation.js

@@ -6,14 +6,14 @@ import {CapabilityProofPurpose} from './CapabilityProofPurpose.js';
 
 /**
  * @typedef {import('./utils.js').InspectCapabilityChain} InspectCapabilityChain
- * @typedef {import('./utils.js').Zcap} Zcap
- * @typedef {import('./utils.js').DelegatedZcap} DelegatedZcap
+ * @typedef {import('./utils.js').IZcap} IZcap
+ * @typedef {import('./utils.js').IDelegatedZcap} IDelegatedZcap
  */
 
 export class CapabilityDelegation extends CapabilityProofPurpose {
   /**
    * @param {object} options - The options.
-   * @param {string|Zcap} [options.parentCapability] - An alternative to
+   * @param {string|IZcap} [options.parentCapability] - An alternative to
    *   passing `capabilityChain` when creating a proof; passing
    *   `parentCapability` will enable the capability chain to be auto-computed.
    *   Pass a root zcap ID string, or a full root or delegated zcap object.
@@ -43,8 +43,8 @@ export class CapabilityDelegation extends CapabilityProofPurpose {
    * @param {object|object[]} [options.suite] - The jsonld-signature suite(s) to
    *   use to verify the capability chain. Required only in verify-proof mode;
    *   unused (and omitted) when creating a delegation proof.
-   * @param {Zcap} [options._verifiedParentCapability] - Private.
-   * @param {Array<string|DelegatedZcap>} [options._capabilityChain] - Private.
+   * @param {IZcap} [options._verifiedParentCapability] - Private.
+   * @param {Array<string|IDelegatedZcap>} [options._capabilityChain] - Private.
    * @param {boolean} [options._skipLocalValidationForTesting] - Private.
    */
   constructor({

package/lib/CapabilityInvocation.js

@@ -7,13 +7,13 @@ import {CapabilityProofPurpose} from './CapabilityProofPurpose.js';
 
 /**
  * @typedef {import('./utils.js').InspectCapabilityChain} InspectCapabilityChain
- * @typedef {import('./utils.js').DelegatedZcap} DelegatedZcap
+ * @typedef {import('./utils.js').IDelegatedZcap} IDelegatedZcap
  */
 
 export class CapabilityInvocation extends CapabilityProofPurpose {
   /**
    * @param {object} options - The options.
-   * @param {string|DelegatedZcap} [options.capability] - The capability to
+   * @param {string|IDelegatedZcap} [options.capability] - The capability to
    *   add/reference in a created proof. A root zcap MUST be passed as its ID
    *   string; a delegated zcap must be passed as the full object.
    * @param {string} [options.capabilityAction] - The capability action that is

package/lib/index.js

@@ -11,10 +11,6 @@ import * as constants from './constants.js';
 export {constants};
 
 /**
- * @typedef {import('./utils.js').RootZcap} RootZcap
- * @typedef {import('./utils.js').DelegatedZcap} DelegatedZcap
- * @typedef {import('./utils.js').Zcap} Zcap
- * @typedef {import('./utils.js').CapabilityDelegationProof} CapabilityDelegationProof
  * @typedef {import('./utils.js').InspectCapabilityChain} InspectCapabilityChain
  * @typedef {import('./utils.js').InspectResult} InspectResult
  * @typedef {import('./utils.js').CapabilityChainDetails} CapabilityChainDetails
@@ -56,5 +52,4 @@ export function extendDocumentLoader(documentLoader) {
  *
  * @type {Function}
  */
-export const documentLoader = extendDocumentLoader(
-  jsigs.strictDocumentLoader);
+export const documentLoader = extendDocumentLoader(jsigs.strictDocumentLoader);

package/lib/utils.js

@@ -13,7 +13,7 @@ import {
  * @param {string|string[]} options.controller - The root controller.
  * @param {string} options.invocationTarget - The root invocation target.
  *
- * @returns {RootZcap} The root capability.
+ * @returns {IRootZcap} The root capability.
  */
 export function createRootCapability({controller, invocationTarget}) {
   return {
@@ -28,7 +28,7 @@ export function createRootCapability({controller, invocationTarget}) {
  * Retrieves the controller(s) from a capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  *
  * @returns {string[]} The controller(s) for the capability.
  */
@@ -45,7 +45,7 @@ export function getControllers({capability}) {
  * controlled by a controller) of the given capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  * @param {object} options.verificationMethod - The verification method to
  *   check.
  *
@@ -61,7 +61,7 @@ export function isController({capability, verificationMethod}) {
  * Retrieves the allowed actions from a capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  *
  * @returns {string[]} Allowed actions.
  */
@@ -80,7 +80,7 @@ export function getAllowedActions({capability}) {
  * Retrieves the target from a capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  *
  * @returns {string} - Capability target.
  */
@@ -95,9 +95,9 @@ export function getTarget({capability}) {
  * delegation proofs will cause this function to return an empty array.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability.
+ * @param {IZcap} options.capability - The authorization capability.
  *
- * @returns {CapabilityDelegationProof[]} Any `capabilityDelegation` proof
+ * @returns {ICapabilityDelegationProof[]} Any `capabilityDelegation` proof
  *   objects attached to the given capability.
  */
 export function getDelegationProofs({capability}) {
@@ -117,9 +117,9 @@ export function getDelegationProofs({capability}) {
  * Gets the `capabilityChain` associated with the given capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability.
+ * @param {IZcap} options.capability - The authorization capability.
  *
- * @returns {Array<string|DelegatedZcap>} The capability chain entries
+ * @returns {Array<string|IDelegatedZcap>} The capability chain entries
  *   (root to parent), as stored in the delegation proof.
  */
 export function getCapabilityChain({capability}) {
@@ -204,12 +204,12 @@ export function isValidTarget({
  * given `parentCapability`.
  *
  * @param {object} options - The options.
- * @param {string|Zcap} options.parentCapability - The parent capability from
+ * @param {string|IZcap} options.parentCapability - The parent capability from
  *   which to compute the capability chain (a root zcap ID string, or a full
  *   root or delegated zcap object).
  * @param {boolean} options._skipLocalValidationForTesting - Private.
  *
- * @returns {Array<string|DelegatedZcap>} The computed capability chain to be
+ * @returns {Array<string|IDelegatedZcap>} The computed capability chain to be
  *   included in a capability delegation proof.
  */
 export function computeCapabilityChain({
@@ -309,7 +309,7 @@ export function computeCapabilityChain({
  * work with both root zcap `a` and `b`).
  *
  * @param {object} options - The options.
- * @param {string|DelegatedZcap} options.capability - The authorization
+ * @param {string|IDelegatedZcap} options.capability - The authorization
  *   capability to dereference the chain for. Pass a string (the root zcap ID)
  *   to dereference a root zcap directly, or a delegated zcap object.
  * @param {Function} options.getRootCapability - A function for dereferencing
@@ -318,7 +318,7 @@ export function computeCapabilityChain({
  * @param {number} [options.maxChainLength=10] - The maximum length of the
  *   capability delegation chain (this is inclusive of `capability` itself).
  *
- * @returns {Promise<{dereferencedChain: Zcap[]}>} Resolves to an object
+ * @returns {Promise<{dereferencedChain: IZcap[]}>} Resolves to an object
  *   containing the full dereferenced chain ordered root to tail.
  */
 export async function dereferenceCapabilityChain({
@@ -592,16 +592,15 @@ export function compareTime({t1, t2, maxClockSkew}) {
 }
 
 /**
- * The zcap object shapes (`RootZcap`, `DelegatedZcap`,
- * `CapabilityDelegationProof`, `Zcap`) are defined in `./zcap-types.d.ts` and
- * re-exported here as typedefs. They cannot be expressed as JSDoc `@typedef`s
- * because TypeScript's JSDoc parser mangles the `@context` property name (the
- * leading `@` becomes an empty-string key). See `./zcap-types.d.ts`.
- *
- * @typedef {import('./zcap-types.js').RootZcap} RootZcap
- * @typedef {import('./zcap-types.js').CapabilityDelegationProof} CapabilityDelegationProof
- * @typedef {import('./zcap-types.js').DelegatedZcap} DelegatedZcap
- * @typedef {import('./zcap-types.js').Zcap} Zcap
+ * The zcap object shapes (`IRootZcap`, `IDelegatedZcap`,
+ * `ICapabilityDelegationProof`, `IZcap`) live in
+ * `@interop/data-integrity-core/zcap` (the canonical home) and are re-imported
+ * here as typedefs for JSDoc use.
+ *
+ * @typedef {import('@interop/data-integrity-core/zcap').IRootZcap} IRootZcap
+ * @typedef {import('@interop/data-integrity-core/zcap').ICapabilityDelegationProof} ICapabilityDelegationProof
+ * @typedef {import('@interop/data-integrity-core/zcap').IDelegatedZcap} IDelegatedZcap
+ * @typedef {import('@interop/data-integrity-core/zcap').IZcap} IZcap
  */
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interop/zcap",
-  "version": "9.0.3",
+  "version": "10.1.0",
   "description": "Authorization Capabilities reference implementation.",
   "homepage": "https://github.com/interop-alliance/zcap",
   "author": {
@@ -32,7 +32,8 @@
   ],
   "dependencies": {
     "@digitalbazaar/zcap-context": "^2.0.1",
-    "@interop/jsonld-signatures": "^11.6.1"
+    "@interop/data-integrity-core": "^6.1.0",
+    "@interop/jsonld-signatures": "^11.6.2"
   },
   "devDependencies": {
     "@digitalbazaar/ed25519-signature-2020": "^5.4.0",
@@ -64,6 +65,7 @@
   "engines": {
     "node": ">=18"
   },
+  "packageManager": "pnpm@11.3.0",
   "keywords": [
     "Authorization Capability",
     "Authorization Capabilities",

package/types/lib/CapabilityDelegation.d.ts

@@ -1,12 +1,12 @@
 /**
  * @typedef {import('./utils.js').InspectCapabilityChain} InspectCapabilityChain
- * @typedef {import('./utils.js').Zcap} Zcap
- * @typedef {import('./utils.js').DelegatedZcap} DelegatedZcap
+ * @typedef {import('./utils.js').IZcap} IZcap
+ * @typedef {import('./utils.js').IDelegatedZcap} IDelegatedZcap
  */
 export class CapabilityDelegation extends CapabilityProofPurpose {
     /**
      * @param {object} options - The options.
-     * @param {string|Zcap} [options.parentCapability] - An alternative to
+     * @param {string|IZcap} [options.parentCapability] - An alternative to
      *   passing `capabilityChain` when creating a proof; passing
      *   `parentCapability` will enable the capability chain to be auto-computed.
      *   Pass a root zcap ID string, or a full root or delegated zcap object.
@@ -36,12 +36,12 @@ export class CapabilityDelegation extends CapabilityProofPurpose {
      * @param {object|object[]} [options.suite] - The jsonld-signature suite(s) to
      *   use to verify the capability chain. Required only in verify-proof mode;
      *   unused (and omitted) when creating a delegation proof.
-     * @param {Zcap} [options._verifiedParentCapability] - Private.
-     * @param {Array<string|DelegatedZcap>} [options._capabilityChain] - Private.
+     * @param {IZcap} [options._verifiedParentCapability] - Private.
+     * @param {Array<string|IDelegatedZcap>} [options._capabilityChain] - Private.
      * @param {boolean} [options._skipLocalValidationForTesting] - Private.
      */
     constructor({ parentCapability, allowTargetAttenuation, controller, date, expectedRootCapability, inspectCapabilityChain, maxChainLength, maxClockSkew, maxDelegationTtl, suite, _verifiedParentCapability, _capabilityChain, _skipLocalValidationForTesting }?: {
-        parentCapability?: string | Zcap;
+        parentCapability?: string | IZcap;
         allowTargetAttenuation?: boolean;
         date?: string | Date | number;
         expectedRootCapability?: string | string[];
@@ -51,14 +51,14 @@ export class CapabilityDelegation extends CapabilityProofPurpose {
         maxClockSkew?: number;
         maxDelegationTtl?: number;
         suite?: object | object[];
-        _verifiedParentCapability?: Zcap;
-        _capabilityChain?: Array<string | DelegatedZcap>;
+        _verifiedParentCapability?: IZcap;
+        _capabilityChain?: Array<string | IDelegatedZcap>;
         _skipLocalValidationForTesting?: boolean;
     });
-    parentCapability: string | import("./zcap-types.js").Zcap;
-    _capabilityChain: (string | import("./zcap-types.js").DelegatedZcap)[];
+    parentCapability: string | import("@interop/data-integrity-core/zcap").IZcap;
+    _capabilityChain: (string | import("@interop/data-integrity-core/zcap").IDelegatedZcap)[];
     _skipLocalValidationForTesting: boolean;
-    _verifiedParentCapability: import("./zcap-types.js").Zcap;
+    _verifiedParentCapability: import("@interop/data-integrity-core/zcap").IZcap;
     update(proof: any, { document }: {
         document: any;
     }): Promise<any>;
@@ -95,7 +95,7 @@ export class CapabilityDelegation extends CapabilityProofPurpose {
     }): Promise<import("@interop/jsonld-signatures").ProofValidateResult>;
 }
 export type InspectCapabilityChain = import("./utils.js").InspectCapabilityChain;
-export type Zcap = import("./utils.js").Zcap;
-export type DelegatedZcap = import("./utils.js").DelegatedZcap;
+export type IZcap = import("./utils.js").IZcap;
+export type IDelegatedZcap = import("./utils.js").IDelegatedZcap;
 import { CapabilityProofPurpose } from './CapabilityProofPurpose.js';
 //# sourceMappingURL=CapabilityDelegation.d.ts.map

package/types/lib/CapabilityDelegation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CapabilityDelegation.d.ts","sourceRoot":"","sources":["../../lib/CapabilityDelegation.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,iQAlCG;QAA8B,gBAAgB,GAAtC,MAAM,GAAC,IAAI;QAIO,sBAAsB,GAAxC,OAAO;QAGsB,IAAI,GAAjC,MAAM,GAAC,IAAI,GAAC,MAAM;QAIQ,sBAAsB,GAAhD,MAAM,GAAC,MAAM,EAAE;QAGE,UAAU,GAA3B,MAAM;QAE2B,sBAAsB,GAAvD,sBAAsB;QAGL,cAAc,GAA/B,MAAM;QAEW,YAAY,GAA7B,MAAM;QAGW,gBAAgB,GAAjC,MAAM;QAGoB,KAAK,GAA/B,MAAM,GAAC,MAAM,EAAE;QAGA,yBAAyB,GAAxC,IAAI;QACkC,gBAAgB,GAAtD,KAAK,CAAC,MAAM,GAAC,aAAa,CAAC;QACT,8BAA8B,GAAhD,OAAO;KACjB,EA0EA;IAbG,0DAAwC;IAKtC,uEAAwC;IAGxC,wCAAoE;IAGtE,0DAA0D;IAI9D;;qBAiFC;IAED;;;yBAUC;IAED,6DAEC;IAED;;;;;MAIC;IAED;;;;OAOC;IAED;;;;;0EAsBC;IAED;;;0EAgBC;IAED;;;;0EA8BC;CACF;qCAhTY,OAAO,YAAY,EAAE,sBAAsB;mBAC3C,OAAO,YAAY,EAAE,IAAI;4BACzB,OAAO,YAAY,EAAE,aAAa;uCALV,6BAA6B"}
+{"version":3,"file":"CapabilityDelegation.d.ts","sourceRoot":"","sources":["../../lib/CapabilityDelegation.js"],"names":[],"mappings":"AAMA;;;;GAIG;AAEH;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,iQAlCG;QAA+B,gBAAgB,GAAvC,MAAM,GAAC,KAAK;QAIM,sBAAsB,GAAxC,OAAO;QAGsB,IAAI,GAAjC,MAAM,GAAC,IAAI,GAAC,MAAM;QAIQ,sBAAsB,GAAhD,MAAM,GAAC,MAAM,EAAE;QAGE,UAAU,GAA3B,MAAM;QAE2B,sBAAsB,GAAvD,sBAAsB;QAGL,cAAc,GAA/B,MAAM;QAEW,YAAY,GAA7B,MAAM;QAGW,gBAAgB,GAAjC,MAAM;QAGoB,KAAK,GAA/B,MAAM,GAAC,MAAM,EAAE;QAGC,yBAAyB,GAAzC,KAAK;QACkC,gBAAgB,GAAvD,KAAK,CAAC,MAAM,GAAC,cAAc,CAAC;QACV,8BAA8B,GAAhD,OAAO;KACjB,EA0EA;IAbG,6EAAwC;IAKtC,0FAAwC;IAGxC,wCAAoE;IAGtE,6EAA0D;IAI9D;;qBAiFC;IAED;;;yBAUC;IAED,6DAEC;IAED;;;;;MAIC;IAED;;;;OAOC;IAED;;;;;0EAsBC;IAED;;;0EAgBC;IAED;;;;0EA8BC;CACF;qCAhTY,OAAO,YAAY,EAAE,sBAAsB;oBAC3C,OAAO,YAAY,EAAE,KAAK;6BAC1B,OAAO,YAAY,EAAE,cAAc;uCALX,6BAA6B"}

package/types/lib/CapabilityInvocation.d.ts

@@ -1,11 +1,11 @@
 /**
  * @typedef {import('./utils.js').InspectCapabilityChain} InspectCapabilityChain
- * @typedef {import('./utils.js').DelegatedZcap} DelegatedZcap
+ * @typedef {import('./utils.js').IDelegatedZcap} IDelegatedZcap
  */
 export class CapabilityInvocation extends CapabilityProofPurpose {
     /**
      * @param {object} options - The options.
-     * @param {string|DelegatedZcap} [options.capability] - The capability to
+     * @param {string|IDelegatedZcap} [options.capability] - The capability to
      *   add/reference in a created proof. A root zcap MUST be passed as its ID
      *   string; a delegated zcap must be passed as the full object.
      * @param {string} [options.capabilityAction] - The capability action that is
@@ -49,7 +49,7 @@ export class CapabilityInvocation extends CapabilityProofPurpose {
      *   unused (and omitted) when creating an invocation proof.
      */
     constructor({ capability, capabilityAction, invocationTarget, allowTargetAttenuation, controller, date, expectedAction, expectedRootCapability, expectedTarget, inspectCapabilityChain, maxChainLength, maxClockSkew, maxDelegationTtl, maxTimestampDelta, suite }?: {
-        capability?: string | DelegatedZcap;
+        capability?: string | IDelegatedZcap;
         capabilityAction?: string;
         invocationTarget?: string;
         allowTargetAttenuation?: boolean;
@@ -65,7 +65,7 @@ export class CapabilityInvocation extends CapabilityProofPurpose {
         maxTimestampDelta?: number;
         suite?: object | object[];
     });
-    capability: string | import("./zcap-types.js").DelegatedZcap;
+    capability: string | import("@interop/data-integrity-core/zcap").IDelegatedZcap;
     capabilityAction: string;
     invocationTarget: string;
     expectedTarget: string | string[];
@@ -94,7 +94,7 @@ export class CapabilityInvocation extends CapabilityProofPurpose {
     }): Promise<import("@interop/jsonld-signatures").ProofValidateResult>;
 }
 export type InspectCapabilityChain = import("./utils.js").InspectCapabilityChain;
-export type DelegatedZcap = import("./utils.js").DelegatedZcap;
+export type IDelegatedZcap = import("./utils.js").IDelegatedZcap;
 import { CapabilityProofPurpose } from './CapabilityProofPurpose.js';
 import { CapabilityDelegation } from './CapabilityDelegation.js';
 //# sourceMappingURL=CapabilityInvocation.d.ts.map

package/types/lib/CapabilityInvocation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CapabilityInvocation.d.ts","sourceRoot":"","sources":["../../lib/CapabilityInvocation.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,qQA3CG;QAAuC,UAAU,GAAzC,MAAM,GAAC,aAAa;QAGH,gBAAgB,GAAjC,MAAM;QAEW,gBAAgB,GAAjC,MAAM;QAGY,sBAAsB,GAAxC,OAAO;QAGU,UAAU,GAA3B,MAAM;QAEuB,IAAI,GAAjC,MAAM,GAAC,IAAI,GAAC,MAAM;QAID,cAAc,GAA/B,MAAM;QAEoB,sBAAsB,GAAhD,MAAM,GAAC,MAAM,EAAE;QAGW,cAAc,GAAxC,MAAM,GAAC,MAAM,EAAE;QAEkB,sBAAsB,GAAvD,sBAAsB;QAGL,cAAc,GAA/B,MAAM;QAEW,YAAY,GAA7B,MAAM;QAIW,gBAAgB,GAAjC,MAAM;QAGW,iBAAiB,GAAlC,MAAM;QAGoB,KAAK,GAA/B,MAAM,GAAC,MAAM,EAAE;KAGzB,EA8FA;IAxBG,6DAA4B;IAC5B,yBAAwC;IACxC,yBAAwC;IAmBxC,kCAAoC;IACpC,uBAAoC;IAIxC,iCAOC;IAED;;;yBA2BC;IAED,6DAEC;IAED;;;;MAEC;IAED;;;;;OA4FC;IAED;;;;0EAgDC;CACF;qCA9UY,OAAO,YAAY,EAAE,sBAAsB;4BAC3C,OAAO,YAAY,EAAE,aAAa;uCAJV,6BAA6B;qCAD/B,2BAA2B"}
+{"version":3,"file":"CapabilityInvocation.d.ts","sourceRoot":"","sources":["../../lib/CapabilityInvocation.js"],"names":[],"mappings":"AAOA;;;GAGG;AAEH;IACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,qQA3CG;QAAwC,UAAU,GAA1C,MAAM,GAAC,cAAc;QAGJ,gBAAgB,GAAjC,MAAM;QAEW,gBAAgB,GAAjC,MAAM;QAGY,sBAAsB,GAAxC,OAAO;QAGU,UAAU,GAA3B,MAAM;QAEuB,IAAI,GAAjC,MAAM,GAAC,IAAI,GAAC,MAAM;QAID,cAAc,GAA/B,MAAM;QAEoB,sBAAsB,GAAhD,MAAM,GAAC,MAAM,EAAE;QAGW,cAAc,GAAxC,MAAM,GAAC,MAAM,EAAE;QAEkB,sBAAsB,GAAvD,sBAAsB;QAGL,cAAc,GAA/B,MAAM;QAEW,YAAY,GAA7B,MAAM;QAIW,gBAAgB,GAAjC,MAAM;QAGW,iBAAiB,GAAlC,MAAM;QAGoB,KAAK,GAA/B,MAAM,GAAC,MAAM,EAAE;KAGzB,EA8FA;IAxBG,gFAA4B;IAC5B,yBAAwC;IACxC,yBAAwC;IAmBxC,kCAAoC;IACpC,uBAAoC;IAIxC,iCAOC;IAED;;;yBA2BC;IAED,6DAEC;IAED;;;;MAEC;IAED;;;;;OA4FC;IAED;;;;0EAgDC;CACF;qCA9UY,OAAO,YAAY,EAAE,sBAAsB;6BAC3C,OAAO,YAAY,EAAE,cAAc;uCAJX,6BAA6B;qCAD/B,2BAA2B"}

package/types/lib/CapabilityProofPurpose.d.ts

@@ -78,7 +78,7 @@ export class CapabilityProofPurpose extends jsigs.ControllerProofPurpose {
         documentLoader: any;
         proof: any;
     }): Promise<{
-        dereferencedChain: import("./zcap-types.js").Zcap[];
+        dereferencedChain: import("@interop/data-integrity-core/zcap").IZcap[];
     }>;
     _getCapabilityDelegationClass(): void;
     _getTailCapability(): Promise<void>;

package/types/lib/index.d.ts

@@ -1,8 +1,4 @@
 /**
- * @typedef {import('./utils.js').RootZcap} RootZcap
- * @typedef {import('./utils.js').DelegatedZcap} DelegatedZcap
- * @typedef {import('./utils.js').Zcap} Zcap
- * @typedef {import('./utils.js').CapabilityDelegationProof} CapabilityDelegationProof
  * @typedef {import('./utils.js').InspectCapabilityChain} InspectCapabilityChain
  * @typedef {import('./utils.js').InspectResult} InspectResult
  * @typedef {import('./utils.js').CapabilityChainDetails} CapabilityChainDetails
@@ -35,10 +31,6 @@ export { constants };
  * @type {Function}
  */
 export const documentLoader: Function;
-export type RootZcap = import("./utils.js").RootZcap;
-export type DelegatedZcap = import("./utils.js").DelegatedZcap;
-export type Zcap = import("./utils.js").Zcap;
-export type CapabilityDelegationProof = import("./utils.js").CapabilityDelegationProof;
 export type InspectCapabilityChain = import("./utils.js").InspectCapabilityChain;
 export type InspectResult = import("./utils.js").InspectResult;
 export type CapabilityChainDetails = import("./utils.js").CapabilityChainDetails;

package/types/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;GASG;AACH,yEAYC;;;;;AAED;;;;;;;GAOG;AACH,sCAC8B;uBA9CjB,OAAO,YAAY,EAAE,QAAQ;4BAC7B,OAAO,YAAY,EAAE,aAAa;mBAClC,OAAO,YAAY,EAAE,IAAI;wCACzB,OAAO,YAAY,EAAE,yBAAyB;qCAC9C,OAAO,YAAY,EAAE,sBAAsB;4BAC3C,OAAO,YAAY,EAAE,aAAa;qCAClC,OAAO,YAAY,EAAE,sBAAsB;6BAC3C,OAAO,YAAY,EAAE,cAAc;2BACnC,OAAO,YAAY,EAAE,YAAY;gCACjC,OAAO,YAAY,EAAE,iBAAiB;uCACtC,OAAO,YAAY,EAAE,wBAAwB;2BAd/B,gBAAgB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AAEH;;;;;;;;;GASG;AACH,yEAYC;;;;;AAED;;;;;;;GAOG;AACH,sCAA+E;qCAzClE,OAAO,YAAY,EAAE,sBAAsB;4BAC3C,OAAO,YAAY,EAAE,aAAa;qCAClC,OAAO,YAAY,EAAE,sBAAsB;6BAC3C,OAAO,YAAY,EAAE,cAAc;2BACnC,OAAO,YAAY,EAAE,YAAY;gCACjC,OAAO,YAAY,EAAE,iBAAiB;uCACtC,OAAO,YAAY,EAAE,wBAAwB;2BAV/B,gBAAgB"}

package/types/lib/utils.d.ts

@@ -6,59 +6,59 @@
  * @param {string|string[]} options.controller - The root controller.
  * @param {string} options.invocationTarget - The root invocation target.
  *
- * @returns {RootZcap} The root capability.
+ * @returns {IRootZcap} The root capability.
  */
 export function createRootCapability({ controller, invocationTarget }: {
     controller: string | string[];
     invocationTarget: string;
-}): RootZcap;
+}): IRootZcap;
 /**
  * Retrieves the controller(s) from a capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  *
  * @returns {string[]} The controller(s) for the capability.
  */
 export function getControllers({ capability }: {
-    capability: Zcap;
+    capability: IZcap;
 }): string[];
 /**
  * Returns true if the given verification method is a controller (or is
  * controlled by a controller) of the given capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  * @param {object} options.verificationMethod - The verification method to
  *   check.
  *
  * @returns {boolean} `true` if the controller matches, `false` if not.
  */
 export function isController({ capability, verificationMethod }: {
-    capability: Zcap;
+    capability: IZcap;
     verificationMethod: object;
 }): boolean;
 /**
  * Retrieves the allowed actions from a capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  *
  * @returns {string[]} Allowed actions.
  */
 export function getAllowedActions({ capability }: {
-    capability: Zcap;
+    capability: IZcap;
 }): string[];
 /**
  * Retrieves the target from a capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability (zcap).
+ * @param {IZcap} options.capability - The authorization capability (zcap).
  *
  * @returns {string} - Capability target.
  */
 export function getTarget({ capability }: {
-    capability: Zcap;
+    capability: IZcap;
 }): string;
 /**
  * Retrieves the delegation proof(s) for a capability that is associated with
@@ -66,26 +66,26 @@ export function getTarget({ capability }: {
  * delegation proofs will cause this function to return an empty array.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability.
+ * @param {IZcap} options.capability - The authorization capability.
  *
- * @returns {CapabilityDelegationProof[]} Any `capabilityDelegation` proof
+ * @returns {ICapabilityDelegationProof[]} Any `capabilityDelegation` proof
  *   objects attached to the given capability.
  */
 export function getDelegationProofs({ capability }: {
-    capability: Zcap;
-}): CapabilityDelegationProof[];
+    capability: IZcap;
+}): ICapabilityDelegationProof[];
 /**
  * Gets the `capabilityChain` associated with the given capability.
  *
  * @param {object} options - The options.
- * @param {Zcap} options.capability - The authorization capability.
+ * @param {IZcap} options.capability - The authorization capability.
  *
- * @returns {Array<string|DelegatedZcap>} The capability chain entries
+ * @returns {Array<string|IDelegatedZcap>} The capability chain entries
  *   (root to parent), as stored in the delegation proof.
  */
 export function getCapabilityChain({ capability }: {
-    capability: Zcap;
-}): Array<string | DelegatedZcap>;
+    capability: IZcap;
+}): Array<string | IDelegatedZcap>;
 /**
  * Determines if the given `invocationTarget` is valid given a
  * `baseInvocationTarget`.
@@ -116,18 +116,18 @@ export function isValidTarget({ invocationTarget, baseInvocationTarget, allowTar
  * given `parentCapability`.
  *
  * @param {object} options - The options.
- * @param {string|Zcap} options.parentCapability - The parent capability from
+ * @param {string|IZcap} options.parentCapability - The parent capability from
  *   which to compute the capability chain (a root zcap ID string, or a full
  *   root or delegated zcap object).
  * @param {boolean} options._skipLocalValidationForTesting - Private.
  *
- * @returns {Array<string|DelegatedZcap>} The computed capability chain to be
+ * @returns {Array<string|IDelegatedZcap>} The computed capability chain to be
  *   included in a capability delegation proof.
  */
 export function computeCapabilityChain({ parentCapability, _skipLocalValidationForTesting }: {
-    parentCapability: string | Zcap;
+    parentCapability: string | IZcap;
     _skipLocalValidationForTesting: boolean;
-}): Array<string | DelegatedZcap>;
+}): Array<string | IDelegatedZcap>;
 /**
  * Dereferences the capability chain associated with the given capability,
  * ensuring it passes a number of validation checks.
@@ -152,7 +152,7 @@ export function computeCapabilityChain({ parentCapability, _skipLocalValidationF
  * work with both root zcap `a` and `b`).
  *
  * @param {object} options - The options.
- * @param {string|DelegatedZcap} options.capability - The authorization
+ * @param {string|IDelegatedZcap} options.capability - The authorization
  *   capability to dereference the chain for. Pass a string (the root zcap ID)
  *   to dereference a root zcap directly, or a delegated zcap object.
  * @param {Function} options.getRootCapability - A function for dereferencing
@@ -161,15 +161,15 @@ export function computeCapabilityChain({ parentCapability, _skipLocalValidationF
  * @param {number} [options.maxChainLength=10] - The maximum length of the
  *   capability delegation chain (this is inclusive of `capability` itself).
  *
- * @returns {Promise<{dereferencedChain: Zcap[]}>} Resolves to an object
+ * @returns {Promise<{dereferencedChain: IZcap[]}>} Resolves to an object
  *   containing the full dereferenced chain ordered root to tail.
  */
 export function dereferenceCapabilityChain({ capability, getRootCapability, maxChainLength }: {
-    capability: string | DelegatedZcap;
+    capability: string | IDelegatedZcap;
     getRootCapability: Function;
     maxChainLength?: number;
 }): Promise<{
-    dereferencedChain: Zcap[];
+    dereferencedChain: IZcap[];
 }>;
 export function checkProofContext({ proof }: {
     proof: any;
@@ -188,37 +188,33 @@ export function compareTime({ t1, t2, maxClockSkew }: {
     maxClockSkew: any;
 }): 0 | 1 | -1;
 /**
- * The zcap object shapes (`RootZcap`, `DelegatedZcap`,
- * `CapabilityDelegationProof`, `Zcap`) are defined in `./zcap-types.d.ts` and
- * re-exported here as typedefs. They cannot be expressed as JSDoc `@typedef`s
- * because TypeScript's JSDoc parser mangles the `@context` property name (the
- * leading `@` becomes an empty-string key). See `./zcap-types.d.ts`.
+ * The zcap object shapes (`IRootZcap`, `IDelegatedZcap`,
+ * `ICapabilityDelegationProof`, `IZcap`) live in
+ * `@interop/data-integrity-core/zcap` (the canonical home) and are re-imported
+ * here as typedefs for JSDoc use.
  */
-export type RootZcap = import("./zcap-types.js").RootZcap;
+export type IRootZcap = import("@interop/data-integrity-core/zcap").IRootZcap;
 /**
- * The zcap object shapes (`RootZcap`, `DelegatedZcap`,
- * `CapabilityDelegationProof`, `Zcap`) are defined in `./zcap-types.d.ts` and
- * re-exported here as typedefs. They cannot be expressed as JSDoc `@typedef`s
- * because TypeScript's JSDoc parser mangles the `@context` property name (the
- * leading `@` becomes an empty-string key). See `./zcap-types.d.ts`.
+ * The zcap object shapes (`IRootZcap`, `IDelegatedZcap`,
+ * `ICapabilityDelegationProof`, `IZcap`) live in
+ * `@interop/data-integrity-core/zcap` (the canonical home) and are re-imported
+ * here as typedefs for JSDoc use.
  */
-export type CapabilityDelegationProof = import("./zcap-types.js").CapabilityDelegationProof;
+export type ICapabilityDelegationProof = import("@interop/data-integrity-core/zcap").ICapabilityDelegationProof;
 /**
- * The zcap object shapes (`RootZcap`, `DelegatedZcap`,
- * `CapabilityDelegationProof`, `Zcap`) are defined in `./zcap-types.d.ts` and
- * re-exported here as typedefs. They cannot be expressed as JSDoc `@typedef`s
- * because TypeScript's JSDoc parser mangles the `@context` property name (the
- * leading `@` becomes an empty-string key). See `./zcap-types.d.ts`.
+ * The zcap object shapes (`IRootZcap`, `IDelegatedZcap`,
+ * `ICapabilityDelegationProof`, `IZcap`) live in
+ * `@interop/data-integrity-core/zcap` (the canonical home) and are re-imported
+ * here as typedefs for JSDoc use.
  */
-export type DelegatedZcap = import("./zcap-types.js").DelegatedZcap;
+export type IDelegatedZcap = import("@interop/data-integrity-core/zcap").IDelegatedZcap;
 /**
- * The zcap object shapes (`RootZcap`, `DelegatedZcap`,
- * `CapabilityDelegationProof`, `Zcap`) are defined in `./zcap-types.d.ts` and
- * re-exported here as typedefs. They cannot be expressed as JSDoc `@typedef`s
- * because TypeScript's JSDoc parser mangles the `@context` property name (the
- * leading `@` becomes an empty-string key). See `./zcap-types.d.ts`.
+ * The zcap object shapes (`IRootZcap`, `IDelegatedZcap`,
+ * `ICapabilityDelegationProof`, `IZcap`) live in
+ * `@interop/data-integrity-core/zcap` (the canonical home) and are re-imported
+ * here as typedefs for JSDoc use.
  */
-export type Zcap = import("./zcap-types.js").Zcap;
+export type IZcap = import("@interop/data-integrity-core/zcap").IZcap;
 /**
  * An inspection function result.
  */

package/types/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,uEALG;IAAiC,UAAU,EAAnC,MAAM,GAAC,MAAM,EAAE;IACC,gBAAgB,EAAhC,MAAM;CAEd,GAAU,QAAQ,CASpB;AAED;;;;;;;GAOG;AACH,+CAJG;IAAsB,UAAU,EAAxB,IAAI;CAEZ,GAAU,MAAM,EAAE,CAQpB;AAED;;;;;;;;;;GAUG;AACH,iEANG;IAAsB,UAAU,EAAxB,IAAI;IACY,kBAAkB,EAAlC,MAAM;CAGd,GAAU,OAAO,CAMnB;AAED;;;;;;;GAOG;AACH,kDAJG;IAAsB,UAAU,EAAxB,IAAI;CAEZ,GAAU,MAAM,EAAE,CAWpB;AAED;;;;;;;GAOG;AACH,0CAJG;IAAsB,UAAU,EAAxB,IAAI;CAEZ,GAAU,MAAM,CAKlB;AAED;;;;;;;;;;GAUG;AACH,oDALG;IAAsB,UAAU,EAAxB,IAAI;CAEZ,GAAU,yBAAyB,EAAE,CAcvC;AAED;;;;;;;;GAQG;AACH,mDALG;IAAsB,UAAU,EAAxB,IAAI;CAEZ,GAAU,KAAK,CAAC,MAAM,GAAC,aAAa,CAAC,CAwBvC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kGAPG;IAAwB,gBAAgB,EAAhC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACW,sBAAsB,EAAvC,OAAO;CAGf,GAAU,OAAO,CAkCnB;AAED;;;;;;;;;;;;GAYG;AACH,6FARG;IAA6B,gBAAgB,EAArC,MAAM,GAAC,IAAI;IAGM,8BAA8B,EAA/C,OAAO;CAEf,GAAU,KAAK,CAAC,MAAM,GAAC,aAAa,CAAC,CA0EvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8FAZG;IAAsC,UAAU,EAAxC,MAAM,GAAC,aAAa;IAGF,iBAAiB;IAGlB,cAAc,GAA/B,MAAM;CAGd,GAAU,OAAO,CAAC;IAAC,iBAAiB,EAAE,IAAI,EAAE,CAAA;CAAC,CAAC,CAkKhD;AAED;;SAQC;AAED;;;YAiBC;AAED;;;SAqEC;AAED;;;;eAOC;;;;;;;;uBASY,OAAO,iBAAiB,EAAE,QAAQ;;;;;;;;wCAClC,OAAO,iBAAiB,EAAE,yBAAyB;;;;;;;;4BACnD,OAAO,iBAAiB,EAAE,aAAa;;;;;;;;mBACvC,OAAO,iBAAiB,EAAE,IAAI;;;;;;;;YAO7B,OAAO;;;;YACP,KAAK;;;;;;;;;;;;;;;QAiBL,MAAM;;;;gBACN,MAAM;;;;;;qBAKN,UAAU,EAAE;;;;;;;yBACZ,cAAc,EAAE;;;;;;;;;;kBAUhB,YAAY;;;;;;;;;;cAQZ,OAAO;;;;;aAEP,iBAAiB,EAAE;;;;;;;;;;wBAQnB,wBAAwB;;;;;;;;;;eAQxB,MAAM"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../lib/utils.js"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,uEALG;IAAiC,UAAU,EAAnC,MAAM,GAAC,MAAM,EAAE;IACC,gBAAgB,EAAhC,MAAM;CAEd,GAAU,SAAS,CASrB;AAED;;;;;;;GAOG;AACH,+CAJG;IAAuB,UAAU,EAAzB,KAAK;CAEb,GAAU,MAAM,EAAE,CAQpB;AAED;;;;;;;;;;GAUG;AACH,iEANG;IAAuB,UAAU,EAAzB,KAAK;IACW,kBAAkB,EAAlC,MAAM;CAGd,GAAU,OAAO,CAMnB;AAED;;;;;;;GAOG;AACH,kDAJG;IAAuB,UAAU,EAAzB,KAAK;CAEb,GAAU,MAAM,EAAE,CAWpB;AAED;;;;;;;GAOG;AACH,0CAJG;IAAuB,UAAU,EAAzB,KAAK;CAEb,GAAU,MAAM,CAKlB;AAED;;;;;;;;;;GAUG;AACH,oDALG;IAAuB,UAAU,EAAzB,KAAK;CAEb,GAAU,0BAA0B,EAAE,CAcxC;AAED;;;;;;;;GAQG;AACH,mDALG;IAAuB,UAAU,EAAzB,KAAK;CAEb,GAAU,KAAK,CAAC,MAAM,GAAC,cAAc,CAAC,CAwBxC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,kGAPG;IAAwB,gBAAgB,EAAhC,MAAM;IACU,oBAAoB,EAApC,MAAM;IACW,sBAAsB,EAAvC,OAAO;CAGf,GAAU,OAAO,CAkCnB;AAED;;;;;;;;;;;;GAYG;AACH,6FARG;IAA8B,gBAAgB,EAAtC,MAAM,GAAC,KAAK;IAGK,8BAA8B,EAA/C,OAAO;CAEf,GAAU,KAAK,CAAC,MAAM,GAAC,cAAc,CAAC,CA0ExC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8FAZG;IAAuC,UAAU,EAAzC,MAAM,GAAC,cAAc;IAGH,iBAAiB;IAGlB,cAAc,GAA/B,MAAM;CAGd,GAAU,OAAO,CAAC;IAAC,iBAAiB,EAAE,KAAK,EAAE,CAAA;CAAC,CAAC,CAkKjD;AAED;;SAQC;AAED;;;YAiBC;AAED;;;SAqEC;AAED;;;;eAOC;;;;;;;wBAQY,OAAO,mCAAmC,EAAE,SAAS;;;;;;;yCACrD,OAAO,mCAAmC,EAAE,0BAA0B;;;;;;;6BACtE,OAAO,mCAAmC,EAAE,cAAc;;;;;;;oBAC1D,OAAO,mCAAmC,EAAE,KAAK;;;;;;;;YAOhD,OAAO;;;;YACP,KAAK;;;;;;;;;;;;;;;QAiBL,MAAM;;;;gBACN,MAAM;;;;;;qBAKN,UAAU,EAAE;;;;;;;yBACZ,cAAc,EAAE;;;;;;;;;;kBAUhB,YAAY;;;;;;;;;;cAQZ,OAAO;;;;;aAEP,iBAAiB,EAAE;;;;;;;;;;wBAQnB,wBAAwB;;;;;;;;;;eAQxB,MAAM"}

package/lib/zcap-types.d.ts

@@ -1,72 +0,0 @@
-/*!
- * Copyright (c) 2018-2026 Digital Bazaar, Inc. All rights reserved.
- */
-
-// Hand-authored object shapes for zcaps. These live in a `.d.ts` (rather than
-// as JSDoc `@typedef`s in `utils.js`) because TypeScript's JSDoc parser cannot
-// express a property named `@context` -- the leading `@` is mangled to an
-// empty-string key (`""`). `utils.js` re-exports these via `@typedef
-// {import('./zcap-types.js').X} X` so the public type names are unchanged.
-
-/**
- * A root authorization capability (zcap). Root zcaps are unsigned, have no
- * `expires` field and no delegation proof.
- */
-export interface RootZcap {
-  /** The zcap JSON-LD context URL. */
-  '@context': string;
-  /** Capability ID (`urn:zcap:root:<encodedTarget>`). */
-  id: string;
-  /** The DID(s) authorized to invoke. */
-  controller: string | string[];
-  /** Resource URI this capability grants access to (absolute URI). */
-  invocationTarget: string;
-}
-
-/** A proof attached to a delegated capability. */
-export interface CapabilityDelegationProof {
-  /** The cryptographic suite type (e.g. `'Ed25519Signature2020'`). */
-  type: string;
-  /** ISO 8601 date-time the proof was created. */
-  created: string;
-  /** Verification method URI used to sign. */
-  verificationMethod: string;
-  /** Always `'capabilityDelegation'`. */
-  proofPurpose: 'capabilityDelegation';
-  /**
-   * Ordered capability chain (root > parent). All entries are string IDs
-   * except the last delegated zcap, which is embedded as an object.
-   */
-  capabilityChain: (string | DelegatedZcap)[];
-  /** The encoded proof value. */
-  proofValue: string;
-}
-
-/**
- * A delegated authorization capability (zcap). Delegated capabilities narrow
- * a parent capability and must carry exactly one `capabilityDelegation` proof.
- */
-export interface DelegatedZcap {
-  /** JSON-LD context array; first entry MUST be the zcap context URL. */
-  '@context': string[];
-  /** Capability ID (absolute URI). */
-  id: string;
-  /** Parent capability ID (absolute URI). */
-  parentCapability: string;
-  /** The DID(s) authorized to invoke. */
-  controller: string | string[];
-  /** Resource URI this capability grants access to (absolute URI). */
-  invocationTarget: string;
-  /**
-   * The action(s) the controller may perform; if absent, no actions are
-   * allowed (except for the root zcap).
-   */
-  allowedAction?: string | string[];
-  /** ISO 8601 date-time when this capability expires. */
-  expires: string;
-  /** The capability delegation proof(s). */
-  proof: CapabilityDelegationProof | CapabilityDelegationProof[];
-}
-
-/** A zcap is either a root or a delegated capability. */
-export type Zcap = RootZcap | DelegatedZcap;