@prosopo/fingerprint 2.7.18 → 2.7.20

package/.turbo/turbo-build$colon$cjs.log

@@ -1,5 +1,5 @@
 
-> @prosopo/fingerprint@2.7.18 build:cjs
+> @prosopo/fingerprint@2.7.20 build:cjs
 > NODE_ENV=${NODE_ENV:-development}; vite build --config vite.cjs.config.ts --mode $NODE_ENV
 
 ViteCommonJSConfig: .
@@ -21,13 +21,15 @@ ViteCommonJSConfig: .
     '@prosopo/util-crypto'
   ]
 }
-vite v6.4.1 building SSR bundle for production...
+The plugin "vite-tsconfig-paths" is detected. Vite now supports tsconfig paths resolution natively via the resolve.tsconfigPaths option. You can remove the plugin and set resolve.tsconfigPaths: true in your Vite config instead.
+vite v8.1.5 building ssr environment for production...
 Bundle build started
-transforming...
-Build end
-✓ 3 modules transformed.
+
+✓ 4 modules transformed.
 rendering chunks...
-dist/cjs/merkle.cjs  2.72 kB
-dist/cjs/proof.cjs   3.17 kB
-dist/cjs/index.cjs   3.38 kB
-✓ built in 202ms
+computing gzip size...
+dist/cjs/index.cjs   2.50 kB │ gzip: 0.89 kB
+dist/cjs/merkle.cjs  2.84 kB │ gzip: 1.09 kB
+dist/cjs/proof.cjs   4.31 kB │ gzip: 1.70 kB
+
+✓ built in 60ms

package/.turbo/turbo-build$colon$tsc.log

@@ -1,8 +1,8 @@
 
-> @prosopo/fingerprint@2.7.18 build:tsc
+> @prosopo/fingerprint@2.7.20 build:tsc
 > tsc --build --verbose
 
-10:22:18 PM - Projects in this build: 
+11:09:46 AM - Projects in this build: 
     * ../../dev/config/tsconfig.json
     * ../fingerprintjs/tsconfig.json
     * ../locale/tsconfig.json
@@ -11,19 +11,19 @@
     * ../types/tsconfig.json
     * tsconfig.json
 
-10:22:19 PM - Project '../../dev/config/tsconfig.json' is up to date because newest input '../../dev/config/src/webpack/webpack.config.ts' is older than output '../../dev/config/tsconfig.tsbuildinfo'
+11:09:46 AM - Project '../../dev/config/tsconfig.json' is up to date because newest input '../../dev/config/src/webpack/webpack.config.ts' is older than output '../../dev/config/tsconfig.tsbuildinfo'
 
-10:22:19 PM - Project '../fingerprintjs/tsconfig.json' is up to date because newest input '../fingerprintjs/src/utils/browser.ts' is older than output '../fingerprintjs/tsconfig.tsbuildinfo'
+11:09:46 AM - Project '../fingerprintjs/tsconfig.json' is up to date because newest input '../fingerprintjs/src/utils/browser.ts' is older than output '../fingerprintjs/tsconfig.tsbuildinfo'
 
-10:22:19 PM - Project '../locale/tsconfig.json' is up to date because newest input '../locale/src/translationKey.ts' is older than output '../locale/tsconfig.tsbuildinfo'
+11:09:46 AM - Project '../locale/tsconfig.json' is up to date because newest input '../locale/src/translationKey.ts' is older than output '../locale/tsconfig.tsbuildinfo'
 
-10:22:19 PM - Project '../util/tsconfig.json' is up to date because newest input '../util/src/url.ts' is older than output '../util/tsconfig.tsbuildinfo'
+11:09:46 AM - Project '../util/tsconfig.json' is up to date because newest input '../util/src/url.ts' is older than output '../util/tsconfig.tsbuildinfo'
 
-10:22:19 PM - Project '../util-crypto/tsconfig.json' is up to date because newest input '../util-crypto/src/types.ts' is older than output '../util-crypto/tsconfig.tsbuildinfo'
+11:09:47 AM - Project '../util-crypto/tsconfig.json' is up to date because newest input '../util-crypto/src/types.ts' is older than output '../util-crypto/tsconfig.tsbuildinfo'
 
-10:22:19 PM - Project '../types/tsconfig.json' is up to date because newest input '../types/src/procaptcha/api.ts' is older than output '../types/tsconfig.tsbuildinfo'
+11:09:47 AM - Project '../types/tsconfig.json' is up to date because newest input '../types/src/types.test-d.ts' is older than output '../types/tsconfig.tsbuildinfo'
 
-10:22:19 PM - Project 'tsconfig.json' is out of date because output file 'tsconfig.tsbuildinfo' does not exist
+11:09:47 AM - Project 'tsconfig.json' is out of date because output file 'tsconfig.tsbuildinfo' does not exist
 
-10:22:19 PM - Building project '/home/runner/work/captcha/captcha/packages/fingerprint/tsconfig.json'...
+11:09:47 AM - Building project '/home/runner/work/captcha/captcha/packages/fingerprint/tsconfig.json'...
 

package/.turbo/turbo-build.log

@@ -1,9 +1,9 @@
 
-> @prosopo/fingerprint@2.7.18 build
+> @prosopo/fingerprint@2.7.20 build
 > npm run build:cross-env -- --mode ${NODE_ENV:-development}
 
 
-> @prosopo/fingerprint@2.7.18 build:cross-env
+> @prosopo/fingerprint@2.7.20 build:cross-env
 > vite build --config vite.esm.config.ts --mode production
 
 ViteEsmConfig: .
@@ -25,13 +25,16 @@ ViteEsmConfig: .
     '@prosopo/util-crypto'
   ]
 }
-vite v6.4.1 building SSR bundle for production...
+The plugin "vite-tsconfig-paths" is detected. Vite now supports tsconfig paths resolution natively via the resolve.tsconfigPaths option. You can remove the plugin and set resolve.tsconfigPaths: true in your Vite config instead.
+vite v8.1.5 building ssr environment for production...
 Bundle build started
-transforming...
-Build end
-✓ 3 modules transformed.
+
+✓ 4 modules transformed.
 rendering chunks...
-dist/index.js   1.92 kB
-dist/merkle.js  2.50 kB
-dist/proof.js   2.92 kB
-✓ built in 174ms
+computing gzip size...
+dist/_virtual/_rolldown/runtime.js  0.04 kB │ gzip: 0.06 kB
+dist/index.js                       2.06 kB │ gzip: 0.81 kB
+dist/merkle.js                      2.68 kB │ gzip: 1.06 kB
+dist/proof.js                       4.03 kB │ gzip: 1.66 kB
+
+✓ built in 77ms

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @prosopo/fingerprint
 
+## 2.7.20
+### Patch Changes
+
+- Updated dependencies [787017b]
+- Updated dependencies [787017b]
+- Updated dependencies [787017b]
+- Updated dependencies [6f19cde]
+  - @prosopo/types@5.0.0
+
+## 2.7.19
+### Patch Changes
+
+- e14fce6: chore(deps): bump vite to 6.4.3 and mongoose to 8.24.1, and adjust types for the mongoose 8.24 Document/ObjectId changes
+- Updated dependencies [103318c]
+- Updated dependencies [270a8d8]
+- Updated dependencies [e14fce6]
+  - @prosopo/types@4.10.0
+
 ## 2.7.18
 ### Patch Changes
 

package/dist/_virtual/_rolldown/runtime.js

@@ -0,0 +1,3 @@
+import "node:module";
+//#endregion
+export {};

package/dist/cjs/index.cjs

@@ -1,82 +1,54 @@
-"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 __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
-));
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const proof = require("./proof.cjs");
-const merkle = require("./merkle.cjs");
-const EXCLUDED_SOURCES = ["webGlExtensions"];
-const FingerprintJSImport = async () => import("@prosopo/fingerprintjs");
-let componentsCache = null;
-const loadComponents = () => {
-  if (!componentsCache) {
-    const pending = (async () => {
-      const { sources, loadSources, prepareForSources } = await FingerprintJSImport();
-      await prepareForSources();
-      const sourceOptions = {
-        cache: {}
-      };
-      const getComponents = loadSources(
-        sources,
-        sourceOptions,
-        EXCLUDED_SOURCES
-      );
-      return getComponents();
-    })();
-    componentsCache = pending;
-    pending.catch(() => {
-      if (componentsCache === pending) {
-        componentsCache = null;
-      }
-    });
-  }
-  return componentsCache;
+const require_merkle = require("./merkle.cjs");
+const require_proof = require("./proof.cjs");
+//#region src/index.ts
+var EXCLUDED_SOURCES = ["webGlExtensions"];
+var FingerprintJSImport = async () => import("@prosopo/fingerprintjs");
+var componentsCache = null;
+var loadComponents = () => {
+	if (!componentsCache) {
+		const pending = (async () => {
+			const { sources, loadSources, prepareForSources } = await FingerprintJSImport();
+			await prepareForSources();
+			return loadSources(sources, { cache: {} }, EXCLUDED_SOURCES)();
+		})();
+		componentsCache = pending;
+		pending.catch(() => {
+			if (componentsCache === pending) componentsCache = null;
+		});
+	}
+	return componentsCache;
 };
-const getFingerprint = async () => {
-  const [{ hashComponents }, components] = await Promise.all([
-    FingerprintJSImport(),
-    loadComponents()
-  ]);
-  return hashComponents(components);
+var getFingerprint = async () => {
+	const [{ hashComponents }, components] = await Promise.all([FingerprintJSImport(), loadComponents()]);
+	return hashComponents(components);
 };
-const getFingerprintProof = async (discloseKeys) => {
-  const components = await loadComponents();
-  return proof.buildFingerprintProofFromComponents(components, discloseKeys);
+/**
+* Produce a proof of fingerprint: a Merkle commitment to the full component set
+* plus a selective disclosure of the requested components. Callers should pass
+* {@link FINGERPRINT_DISCLOSURE_KEYS} — omitting `discloseKeys` discloses every
+* component, which produces a very large payload. Derived from the same
+* component run as {@link getFingerprint}.
+*/
+var getFingerprintProof = async (discloseKeys) => {
+	const components = await loadComponents();
+	return require_proof.buildFingerprintProofFromComponents(components, discloseKeys);
 };
-const prefetchFingerprint = () => {
-  loadComponents().catch(() => {
-  });
+var prefetchFingerprint = () => {
+	loadComponents().catch(() => {});
 };
-exports.FINGERPRINT_DISCLOSURE_KEYS = proof.FINGERPRINT_DISCLOSURE_KEYS;
-exports.FINGERPRINT_PROOF_VERSION = proof.FINGERPRINT_PROOF_VERSION;
-exports.buildFingerprintProofFromComponents = proof.buildFingerprintProofFromComponents;
-exports.encodeFingerprintProof = proof.encodeFingerprintProof;
-exports.leafHashForContent = proof.leafHashForContent;
-exports.verifyFingerprintProofStructure = proof.verifyFingerprintProofStructure;
-exports.buildMerkleLayers = merkle.buildMerkleLayers;
-exports.hashMerklePair = merkle.hashMerklePair;
-exports.merkleProofFromLayers = merkle.merkleProofFromLayers;
-exports.merkleRootFromLayers = merkle.merkleRootFromLayers;
-exports.verifyMerkleProof = merkle.verifyMerkleProof;
+//#endregion
+exports.FINGERPRINT_DISCLOSURE_KEYS = require_proof.FINGERPRINT_DISCLOSURE_KEYS;
+exports.FINGERPRINT_PROOF_VERSION = require_proof.FINGERPRINT_PROOF_VERSION;
+exports.buildFingerprintProofFromComponents = require_proof.buildFingerprintProofFromComponents;
+exports.buildMerkleLayers = require_merkle.buildMerkleLayers;
+exports.encodeFingerprintProof = require_proof.encodeFingerprintProof;
 exports.getFingerprint = getFingerprint;
 exports.getFingerprintProof = getFingerprintProof;
+exports.hashMerklePair = require_merkle.hashMerklePair;
+exports.leafHashForContent = require_proof.leafHashForContent;
+exports.merkleProofFromLayers = require_merkle.merkleProofFromLayers;
+exports.merkleRootFromLayers = require_merkle.merkleRootFromLayers;
 exports.prefetchFingerprint = prefetchFingerprint;
+exports.verifyFingerprintProofStructure = require_proof.verifyFingerprintProofStructure;
+exports.verifyMerkleProof = require_merkle.verifyMerkleProof;

package/dist/cjs/merkle.cjs

@@ -1,81 +1,71 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const utilCrypto = require("@prosopo/util-crypto");
-const at = (arr, index) => {
-  const value = arr[index];
-  if (value === void 0) {
-    throw new Error(
-      `merkle: index ${index} out of range (length ${arr.length})`
-    );
-  }
-  return value;
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+//#region src/merkle.ts
+var at = (arr, index) => {
+	const value = arr[index];
+	if (value === void 0) throw new Error(`merkle: index ${index} out of range (length ${arr.length})`);
+	return value;
 };
-const hashMerklePair = (left, right) => utilCrypto.hexHashArray([left, right]);
-const buildMerkleLayers = (leafHashes) => {
-  if (leafHashes.length === 0) {
-    throw new Error("merkle: cannot build a tree with no leaves");
-  }
-  const layers = [[...leafHashes]];
-  let current = leafHashes;
-  while (current.length > 1) {
-    const next = [];
-    for (let i = 0; i < current.length; i += 2) {
-      const left = at(current, i);
-      const right = i + 1 < current.length ? at(current, i + 1) : left;
-      next.push(hashMerklePair(left, right));
-    }
-    layers.push(next);
-    current = next;
-  }
-  return layers;
+/** Hash a pair of child hashes into their parent. */
+var hashMerklePair = (left, right) => (0, _prosopo_util_crypto.hexHashArray)([left, right]);
+/**
+* Build every layer of the Merkle tree, bottom-up. Layer 0 is the leaf hashes,
+* the final layer is `[root]`. An odd node at the end of a layer is paired with
+* itself.
+*/
+var buildMerkleLayers = (leafHashes) => {
+	if (leafHashes.length === 0) throw new Error("merkle: cannot build a tree with no leaves");
+	const layers = [[...leafHashes]];
+	let current = leafHashes;
+	while (current.length > 1) {
+		const next = [];
+		for (let i = 0; i < current.length; i += 2) {
+			const left = at(current, i);
+			const right = i + 1 < current.length ? at(current, i + 1) : left;
+			next.push(hashMerklePair(left, right));
+		}
+		layers.push(next);
+		current = next;
+	}
+	return layers;
 };
-const merkleRootFromLayers = (layers) => at(at(layers, layers.length - 1), 0);
-const merkleProofFromLayers = (layers, leafHash) => {
-  const proof = [];
-  let hash = leafHash;
-  for (let layerNum = 0; layerNum < layers.length - 1; layerNum++) {
-    const layer = at(layers, layerNum);
-    const index = layer.indexOf(hash);
-    if (index === -1) {
-      throw new Error("merkle: leaf hash not present in layer");
-    }
-    let partnerIndex = index % 2 === 1 ? index - 1 : index + 1;
-    if (partnerIndex > layer.length - 1) {
-      partnerIndex = index;
-    }
-    const partner = at(layer, partnerIndex);
-    const pair = partnerIndex > index ? [hash, partner] : [partner, hash];
-    proof.push(pair);
-    hash = hashMerklePair(pair[0], pair[1]);
-  }
-  return [...proof, [merkleRootFromLayers(layers)]];
+var merkleRootFromLayers = (layers) => at(at(layers, layers.length - 1), 0);
+/** Produce the sibling path proving `leafHash` belongs to the tree. */
+var merkleProofFromLayers = (layers, leafHash) => {
+	const proof = [];
+	let hash = leafHash;
+	for (let layerNum = 0; layerNum < layers.length - 1; layerNum++) {
+		const layer = at(layers, layerNum);
+		const index = layer.indexOf(hash);
+		if (index === -1) throw new Error("merkle: leaf hash not present in layer");
+		let partnerIndex = index % 2 === 1 ? index - 1 : index + 1;
+		if (partnerIndex > layer.length - 1) partnerIndex = index;
+		const partner = at(layer, partnerIndex);
+		const pair = partnerIndex > index ? [hash, partner] : [partner, hash];
+		proof.push(pair);
+		hash = hashMerklePair(pair[0], pair[1]);
+	}
+	return [...proof, [merkleRootFromLayers(layers)]];
 };
-const verifyMerkleProof = (leafHash, proof) => {
-  try {
-    const firstLayer = proof[0];
-    if (firstLayer === void 0 || firstLayer.indexOf(leafHash) === -1) {
-      return false;
-    }
-    if (proof.length === 1) {
-      return at(firstLayer, 0) === leafHash;
-    }
-    const root = at(at(proof, proof.length - 1), 0);
-    let hash = leafHash;
-    for (let i = 0; i < proof.length - 1; i++) {
-      const layer = at(proof, i);
-      if (layer.indexOf(hash) === -1) {
-        return false;
-      }
-      hash = hashMerklePair(at(layer, 0), at(layer, 1));
-      if (at(proof, i + 1).indexOf(hash) === -1) {
-        return false;
-      }
-    }
-    return hash === root;
-  } catch {
-    return false;
-  }
+/** Verify a leaf + sibling path recomputes to the proof's embedded root. */
+var verifyMerkleProof = (leafHash, proof) => {
+	try {
+		const firstLayer = proof[0];
+		if (firstLayer === void 0 || firstLayer.indexOf(leafHash) === -1) return false;
+		if (proof.length === 1) return at(firstLayer, 0) === leafHash;
+		const root = at(at(proof, proof.length - 1), 0);
+		let hash = leafHash;
+		for (let i = 0; i < proof.length - 1; i++) {
+			const layer = at(proof, i);
+			if (layer.indexOf(hash) === -1) return false;
+			hash = hashMerklePair(at(layer, 0), at(layer, 1));
+			if (at(proof, i + 1).indexOf(hash) === -1) return false;
+		}
+		return hash === root;
+	} catch {
+		return false;
+	}
 };
+//#endregion
 exports.buildMerkleLayers = buildMerkleLayers;
 exports.hashMerklePair = hashMerklePair;
 exports.merkleProofFromLayers = merkleProofFromLayers;

package/dist/cjs/proof.cjs

@@ -1,81 +1,99 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const utilCrypto = require("@prosopo/util-crypto");
-const merkle = require("./merkle.cjs");
-const FINGERPRINT_PROOF_VERSION = 1;
-const FINGERPRINT_DISCLOSURE_KEYS = [
-  "colorDepth",
-  "cookiesEnabled",
-  "sessionStorage",
-  "localStorage",
-  "timezone",
-  "hardwareConcurrency",
-  "languages",
-  "architecture"
+const require_merkle = require("./merkle.cjs");
+let _prosopo_util_crypto = require("@prosopo/util-crypto");
+//#region src/proof.ts
+var FINGERPRINT_PROOF_VERSION = 1;
+/**
+* The fixed set of components the client discloses in a proof of fingerprint.
+* Disclosing every component (the previous default) made the proof enormous —
+* each disclosure carries a full Merkle path and its raw value, and components
+* like webgl/audio/fonts have very large values. Selective disclosure keeps the
+* commitment (`root`) over the whole component set while only these cheap,
+* stable scalar components carry a path + value, shrinking the payload ~10x.
+*
+* The provider-side validator's bounds MUST be a subset of these keys: a bounded
+* key that isn't disclosed would always fail validation as `missing:<key>`.
+*/
+var FINGERPRINT_DISCLOSURE_KEYS = [
+	"colorDepth",
+	"cookiesEnabled",
+	"sessionStorage",
+	"localStorage",
+	"timezone",
+	"hardwareConcurrency",
+	"languages",
+	"architecture"
 ];
-const escapeKey = (key) => key.replace(/([:|\\])/g, "\\$1");
-const componentLeafContent = (key, component) => {
-  const serialized = "error" in component ? "error" : JSON.stringify(component.value);
-  return `${escapeKey(key)}:${serialized}`;
+var escapeKey = (key) => key.replace(/([:|\\])/g, "\\$1");
+var componentLeafContent = (key, component) => {
+	const serialized = "error" in component ? "error" : JSON.stringify(component.value);
+	return `${escapeKey(key)}:${serialized}`;
 };
-const disclosureLeafContent = (disclosure) => {
-  const serialized = disclosure.error ? "error" : JSON.stringify(disclosure.value);
-  return `${escapeKey(disclosure.key)}:${serialized}`;
+var disclosureLeafContent = (disclosure) => {
+	const serialized = disclosure.error ? "error" : JSON.stringify(disclosure.value);
+	return `${escapeKey(disclosure.key)}:${serialized}`;
 };
-const leafHashForContent = (content) => utilCrypto.hexHash(content);
-const buildFingerprintProofFromComponents = (components, discloseKeys) => {
-  const keys = Object.keys(components).sort();
-  if (keys.length === 0) {
-    throw new Error("fingerprint proof: no components to commit to");
-  }
-  const leafHashes = keys.map((key) => {
-    const component = components[key];
-    if (component === void 0) {
-      throw new Error(`fingerprint proof: missing component ${key}`);
-    }
-    return leafHashForContent(componentLeafContent(key, component));
-  });
-  const layers = merkle.buildMerkleLayers(leafHashes);
-  const root = merkle.merkleRootFromLayers(layers);
-  const disclose = discloseKeys ?? keys;
-  const disclosures = [];
-  for (const key of disclose) {
-    const index = keys.indexOf(key);
-    if (index === -1) {
-      continue;
-    }
-    const component = components[key];
-    const leafHash = leafHashes[index];
-    if (component === void 0 || leafHash === void 0) {
-      continue;
-    }
-    const proof = merkle.merkleProofFromLayers(layers, leafHash);
-    disclosures.push(
-      "error" in component ? { key, error: true, proof } : { key, value: component.value, proof }
-    );
-  }
-  return { v: FINGERPRINT_PROOF_VERSION, root, disclosures };
+var leafHashForContent = (content) => (0, _prosopo_util_crypto.hexHash)(content);
+/**
+* Build a {@link FingerprintProof} from an already-resolved FingerprintJS
+* components map. The commitment always covers every component (in sorted key
+* order); `discloseKeys` selects which components are revealed (defaulting to
+* all). Keys that are not present in the fingerprint are skipped — a validator
+* should treat an expected-but-absent disclosure as a failure.
+*/
+var buildFingerprintProofFromComponents = (components, discloseKeys) => {
+	const keys = Object.keys(components).sort();
+	if (keys.length === 0) throw new Error("fingerprint proof: no components to commit to");
+	const leafHashes = keys.map((key) => {
+		const component = components[key];
+		if (component === void 0) throw new Error(`fingerprint proof: missing component ${key}`);
+		return leafHashForContent(componentLeafContent(key, component));
+	});
+	const layers = require_merkle.buildMerkleLayers(leafHashes);
+	const root = require_merkle.merkleRootFromLayers(layers);
+	const disclose = discloseKeys ?? keys;
+	const disclosures = [];
+	for (const key of disclose) {
+		const index = keys.indexOf(key);
+		if (index === -1) continue;
+		const component = components[key];
+		const leafHash = leafHashes[index];
+		if (component === void 0 || leafHash === void 0) continue;
+		const proof = require_merkle.merkleProofFromLayers(layers, leafHash);
+		disclosures.push("error" in component ? {
+			key,
+			error: true,
+			proof
+		} : {
+			key,
+			value: component.value,
+			proof
+		});
+	}
+	return {
+		v: 1,
+		root,
+		disclosures
+	};
 };
-const verifyFingerprintProofStructure = (proof) => {
-  if (proof.v !== FINGERPRINT_PROOF_VERSION) {
-    return false;
-  }
-  if (typeof proof.root !== "string" || proof.disclosures.length === 0) {
-    return false;
-  }
-  for (const disclosure of proof.disclosures) {
-    const leafHash = leafHashForContent(disclosureLeafContent(disclosure));
-    if (!merkle.verifyMerkleProof(leafHash, disclosure.proof)) {
-      return false;
-    }
-    const rootLayer = disclosure.proof[disclosure.proof.length - 1];
-    if (rootLayer === void 0 || rootLayer[0] !== proof.root) {
-      return false;
-    }
-  }
-  return true;
+/**
+* Structural verification of a proof: every disclosed `(key, value)` re-hashes
+* to a leaf that is proven to belong to the single committed `root`. This is
+* the non-secret half of validation — the value-bounding rules live in the
+* provider-side (closed-source) validator and are layered on top of this.
+*/
+var verifyFingerprintProofStructure = (proof) => {
+	if (proof.v !== 1) return false;
+	if (typeof proof.root !== "string" || proof.disclosures.length === 0) return false;
+	for (const disclosure of proof.disclosures) {
+		const leafHash = leafHashForContent(disclosureLeafContent(disclosure));
+		if (!require_merkle.verifyMerkleProof(leafHash, disclosure.proof)) return false;
+		const rootLayer = disclosure.proof[disclosure.proof.length - 1];
+		if (rootLayer === void 0 || rootLayer[0] !== proof.root) return false;
+	}
+	return true;
 };
-const encodeFingerprintProof = (proof) => JSON.stringify(proof);
+var encodeFingerprintProof = (proof) => JSON.stringify(proof);
+//#endregion
 exports.FINGERPRINT_DISCLOSURE_KEYS = FINGERPRINT_DISCLOSURE_KEYS;
 exports.FINGERPRINT_PROOF_VERSION = FINGERPRINT_PROOF_VERSION;
 exports.buildFingerprintProofFromComponents = buildFingerprintProofFromComponents;