@cloudglides/veil 1.0.0 → 1.0.2

package/src/entropy/statistical.ts

@@ -1,15 +0,0 @@
-export async function getStatisticalEntropy(): Promise<string> {
-  const ua = navigator.userAgent;
-  const freq: Record<string, number> = {};
-  
-  for (const char of ua) {
-    freq[char] = (freq[char] || 0) + 1;
-  }
-
-  const values = Object.values(freq);
-  const mean = values.reduce((a, b) => a + b) / values.length;
-  const variance = values.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / values.length;
-  const stdDev = Math.sqrt(variance);
-
-  return `mean:${mean.toFixed(4)}|var:${variance.toFixed(4)}|std:${stdDev.toFixed(4)}`;
-}

package/src/entropy/storage.ts

@@ -1,22 +0,0 @@
-export async function getStorageEntropy(): Promise<string> {
-  let ls = false;
-  let idb = false;
-
-  try {
-    const test = "__storage_test__";
-    window.localStorage.setItem(test, test);
-    window.localStorage.removeItem(test);
-    ls = true;
-  } catch {
-    ls = false;
-  }
-
-  try {
-    const request = window.indexedDB.open("__idb_test__");
-    idb = true;
-  } catch {
-    idb = false;
-  }
-
-  return `localStorage:${ls}|indexedDB:${idb}`;
-}

package/src/entropy/timezone.ts

@@ -1,10 +0,0 @@
-export async function getTimezoneEntropy(): Promise<string> {
-  const tz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  const offset = new Date().getTimezoneOffset();
-  
-  const tzEntropy = Math.log2(Math.abs(offset) + 1);
-  const offsetBits = offset.toString().length * 8;
-  const tzUniqueness = Math.log2(24 * 60 / Math.max(Math.abs(offset), 1));
-  
-  return `TZ:${tz}|offset:${offset}|H(TZ)=${tzEntropy.toFixed(3)}|U=${tzUniqueness.toFixed(3)}`;
-}

package/src/entropy/userAgent.ts

@@ -1,16 +0,0 @@
-export async function getUserAgentEntropy(): Promise<string> {
-  const ua = navigator.userAgent;
-  
-  let entropy = 0;
-  const freq: Record<string, number> = {};
-  for (const char of ua) {
-    freq[char] = (freq[char] || 0) + 1;
-  }
-  
-  for (const count of Object.values(freq)) {
-    const p = count / ua.length;
-    entropy -= p * Math.log2(p);
-  }
-  
-  return `${ua}|H(UA)=${entropy.toFixed(4)}`;
-}

package/src/entropy/webFeatures.ts

@@ -1,21 +0,0 @@
-export async function getWebFeaturesEntropy(): Promise<string> {
-  const features = {
-    localStorage: !!window.localStorage,
-    sessionStorage: !!window.sessionStorage,
-    indexedDB: !!window.indexedDB,
-    openDatabase: !!(window as any).openDatabase,
-    serviceWorker: !!navigator.serviceWorker,
-    webWorker: typeof Worker !== "undefined",
-    geolocation: !!navigator.geolocation,
-    notifications: !!window.Notification,
-  };
-  
-  const enabled = Object.values(features).filter(Boolean).length;
-  const total = Object.keys(features).length;
-  const supportRatio = enabled / total;
-  const supportEntropy = Math.log2(total) * (1 - Math.abs(supportRatio - 0.5) * 2);
-  
-  return `enabled:${enabled}/${total}|σ=${supportRatio.toFixed(3)}|H(features)=${supportEntropy.toFixed(3)}|${Object.entries(features)
-    .map(([k, v]) => `${k}:${v}`)
-    .join("|")}`;
-}

package/src/entropy/webgl.ts

@@ -1,11 +0,0 @@
-export async function getWebGLEntropy(): Promise<string> {
-  const canvas = document.createElement("canvas");
-  const gl = canvas.getContext("webgl") || canvas.getContext("webgl2");
-  if (!gl) return "webgl:unavailable";
-
-  const vendor = gl.getParameter(gl.VENDOR) || "unknown";
-  const renderer = gl.getParameter(gl.RENDERER) || "unknown";
-  const version = gl.getParameter(gl.VERSION) || "unknown";
-  
-  return `vendor:${vendor}|renderer:${renderer}|version:${version}`;
-}

package/src/gpu.ts

@@ -1,132 +0,0 @@
-export async function runGPUBenchmark(): Promise<{
-  renderTime: number;
-  textureOps: number;
-  shaderPerformance: number;
-}> {
-  const canvas = document.createElement("canvas");
-  canvas.width = 512;
-  canvas.height = 512;
-
-  const gl = canvas.getContext("webgl2") || canvas.getContext("webgl");
-  if (!gl) {
-    return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
-  }
-
-  const start = performance.now();
-
-  const vertexShader = gl.createShader(gl.VERTEX_SHADER);
-  if (!vertexShader) return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
-  
-  gl.shaderSource(
-    vertexShader,
-    `
-    attribute vec2 position;
-    void main() {
-      gl_Position = vec4(position, 0.0, 1.0);
-    }
-  `,
-  );
-  gl.compileShader(vertexShader);
-
-  const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
-  if (!fragmentShader) return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
-  
-  gl.shaderSource(
-    fragmentShader,
-    `
-    precision highp float;
-    uniform sampler2D tex;
-    void main() {
-      gl_FragColor = texture2D(tex, vec2(0.5, 0.5));
-    }
-  `,
-  );
-  gl.compileShader(fragmentShader);
-
-  const program = gl.createProgram();
-  if (!program) return { renderTime: 0, textureOps: 0, shaderPerformance: 0 };
-  
-  gl.attachShader(program, vertexShader);
-  gl.attachShader(program, fragmentShader);
-  gl.linkProgram(program);
-  gl.useProgram(program);
-
-  const positionBuffer = gl.createBuffer();
-  gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
-  gl.bufferData(
-    gl.ARRAY_BUFFER,
-    new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]),
-    gl.STATIC_DRAW,
-  );
-
-  const texture = gl.createTexture();
-  gl.bindTexture(gl.TEXTURE_2D, texture);
-  gl.texImage2D(
-    gl.TEXTURE_2D,
-    0,
-    gl.RGBA,
-    256,
-    256,
-    0,
-    gl.RGBA,
-    gl.UNSIGNED_BYTE,
-    new Uint8Array(256 * 256 * 4).fill(128),
-  );
-
-  for (let i = 0; i < 100; i++) {
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.drawArrays(gl.TRIANGLE_STRIP, 0, 4);
-  }
-
-  gl.readPixels(0, 0, 1, 1, gl.RGBA, gl.UNSIGNED_BYTE, new Uint8Array(4));
-
-  const renderTime = performance.now() - start;
-
-  const textureOps = 100;
-  const shaderPerformance = 512 * 512 * 100 / (renderTime || 1);
-
-  gl.deleteShader(vertexShader);
-  gl.deleteShader(fragmentShader);
-  gl.deleteProgram(program);
-  gl.deleteBuffer(positionBuffer);
-  gl.deleteTexture(texture);
-
-  canvas.remove();
-
-  return {
-    renderTime,
-    textureOps,
-    shaderPerformance,
-  };
-}
-
-export async function getGPUHash(): Promise<string> {
-  const benchmark = await runGPUBenchmark();
-  const canvas = document.createElement("canvas");
-  canvas.width = 256;
-  canvas.height = 256;
-
-  const ctx = canvas.getContext("2d");
-  if (!ctx) return "";
-
-  for (let i = 0; i < 256; i++) {
-    for (let j = 0; j < 256; j++) {
-      const hue = (benchmark.renderTime * (i + j)) % 360;
-      const sat = (benchmark.shaderPerformance * i) % 100;
-      const lum = (benchmark.textureOps * j) % 100;
-
-      ctx.fillStyle = `hsl(${hue}, ${sat}%, ${lum}%)`;
-      ctx.fillRect(i, j, 1, 1);
-    }
-  }
-
-  const imageData = ctx.getImageData(0, 0, 256, 256);
-  const data = imageData.data;
-
-  let hash = 0;
-  for (let i = 0; i < data.length; i += 4) {
-    hash ^= ((data[i] + data[i + 1] + data[i + 2]) * (i * 1)) >> 0;
-  }
-
-  return hash.toString(16);
-}

package/src/index.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { getFingerprint } from "./index";
-
-describe("veil fingerprinting", () => {
-  it("should generate consistent fingerprint", async () => {
-    const fp1 = await getFingerprint();
-    const fp2 = await getFingerprint();
-    expect(fp1).toBe(fp2);
-  });
-
-  it("should generate different fingerprints with different options", async () => {
-    const fp1 = await getFingerprint({ entropy: { canvas: true } });
-    const fp2 = await getFingerprint({ entropy: { canvas: false } });
-    expect(fp1).not.toBe(fp2);
-  });
-
-  it("should support SHA-512", async () => {
-    const fp = await getFingerprint({ hash: "sha512" });
-    expect(fp.length).toBeGreaterThan(64);
-  });
-
-  it("should return hex string", async () => {
-    const fp = await getFingerprint();
-    expect(/^[a-f0-9]+$/.test(fp)).toBe(true);
-  });
-});

package/src/index.ts

@@ -1,198 +0,0 @@
-import type { FingerprintOptions, FingerprintResponse, SourceMetric } from "./types";
-import { getUserAgentEntropy } from "./entropy/userAgent";
-import { getCanvasEntropy } from "./entropy/canvas";
-import { getWebGLEntropy } from "./entropy/webgl";
-import { getFontsEntropy } from "./entropy/fonts";
-import { getStorageEntropy } from "./entropy/storage";
-import { getScreenEntropy } from "./entropy/screen";
-import { getDistributionEntropy } from "./entropy/distribution";
-import { getComplexityEntropy } from "./entropy/complexity";
-import { getSpectralEntropy } from "./entropy/spectral";
-import { getApproximateEntropy } from "./entropy/approximate";
-import { getOSEntropy } from "./entropy/os";
-import { getLanguageEntropy } from "./entropy/language";
-import { getTimezoneEntropy } from "./entropy/timezone";
-import { getHardwareEntropy } from "./entropy/hardware";
-import { getPluginsEntropy } from "./entropy/plugins";
-import { getBrowserEntropy } from "./entropy/browser";
-import { getOSVersionEntropy } from "./entropy/osVersion";
-import { getScreenInfoEntropy } from "./entropy/screenInfo";
-import { getAdblockEntropy } from "./entropy/adblock";
-import { getWebFeaturesEntropy } from "./entropy/webFeatures";
-import { getPreferencesEntropy } from "./entropy/preferences";
-import { getPermissionsEntropy } from "./entropy/permissions";
-import { getStatisticalEntropy } from "./entropy/statistical";
-import { getProbabilisticEntropy } from "./entropy/probabilistic";
-import {
-  murmur_hash,
-  fnv_hash,
-  shannon_entropy,
-  kolmogorov_complexity,
-} from "./veil_core.js";
-import * as normalize from "./normalize";
-import { initializeWasm } from "./wasm-loader";
-import { scoreFingerprint, calculateEntropy, type EntropySource } from "./scoring";
-import { getGPUHash, runGPUBenchmark } from "./gpu";
-import { getCPUHash, runCPUBenchmark } from "./cpu";
-import { seededRng } from "./seeded-rng";
-
-export async function getFingerprint(
-  options?: FingerprintOptions,
-): Promise<string | FingerprintResponse> {
-  await initializeWasm();
-
-  const opts = {
-    entropy: {},
-    hash: "sha256",
-    ...options,
-  };
-
-  const sources: EntropySource[] = [];
-
-  if (opts.entropy.userAgent !== false) {
-    const value = await getUserAgentEntropy();
-    sources.push({ name: "userAgent", value, entropy: calculateEntropy(value) });
-  }
-
-  if (opts.entropy.canvas !== false) {
-    const value = await getCanvasEntropy();
-    sources.push({ name: "canvas", value, entropy: calculateEntropy(value) });
-  }
-
-  if (opts.entropy.webgl !== false) {
-    const value = await getWebGLEntropy();
-    sources.push({ name: "webgl", value, entropy: calculateEntropy(value) });
-  }
-
-  if (opts.entropy.fonts !== false) {
-    const value = await getFontsEntropy();
-    sources.push({ name: "fonts", value, entropy: calculateEntropy(value) });
-  }
-
-  if (opts.entropy.storage !== false) {
-    const value = await getStorageEntropy();
-    sources.push({ name: "storage", value, entropy: calculateEntropy(value) });
-  }
-
-  if (opts.entropy.screen !== false) {
-    const value = await getScreenEntropy();
-    sources.push({ name: "screen", value, entropy: calculateEntropy(value) });
-  }
-
-  const baseSeed = sources.map(s => s.value).join("|");
-  
-  sources.push({ name: "distribution", value: await getDistributionEntropy(baseSeed), entropy: 0 });
-  sources.push({ name: "complexity", value: await getComplexityEntropy(), entropy: 0 });
-  sources.push({ name: "spectral", value: await getSpectralEntropy(baseSeed), entropy: 0 });
-  sources.push({ name: "approximate", value: await getApproximateEntropy(baseSeed), entropy: 0 });
-  sources.push({ name: "os", value: await getOSEntropy(), entropy: 0 });
-  sources.push({ name: "language", value: await getLanguageEntropy(), entropy: 0 });
-  sources.push({ name: "timezone", value: await getTimezoneEntropy(), entropy: 0 });
-  sources.push({ name: "hardware", value: await getHardwareEntropy(), entropy: 0 });
-  sources.push({ name: "plugins", value: await getPluginsEntropy(), entropy: 0 });
-  sources.push({ name: "browser", value: await getBrowserEntropy(), entropy: 0 });
-  sources.push({ name: "osVersion", value: await getOSVersionEntropy(), entropy: 0 });
-  sources.push({ name: "screenInfo", value: await getScreenInfoEntropy(), entropy: 0 });
-  sources.push({ name: "adblock", value: await getAdblockEntropy(), entropy: 0 });
-  sources.push({ name: "webFeatures", value: await getWebFeaturesEntropy(), entropy: 0 });
-  sources.push({ name: "preferences", value: await getPreferencesEntropy(), entropy: 0 });
-  sources.push({ name: "permissions", value: await getPermissionsEntropy(), entropy: 0 });
-  sources.push({ name: "statistical", value: await getStatisticalEntropy(), entropy: 0 });
-  sources.push({ name: "probabilistic", value: await getProbabilisticEntropy(), entropy: 0 });
-
-  for (const source of sources) {
-    if (source.entropy === 0) {
-      source.entropy = calculateEntropy(source.value);
-    }
-  }
-
-  const score = scoreFingerprint(sources);
-
-  const data = sources.map(s => s.value);
-
-  const dataStr = data.join("|");
-  const shannon = shannon_entropy(dataStr);
-  const kolmogorov = kolmogorov_complexity(dataStr);
-  const murmur = murmur_hash(dataStr);
-  const fnv = fnv_hash(dataStr);
-
-  const mathMetrics = `${shannon}|${kolmogorov}|${murmur}|${fnv}`;
-  const combined = dataStr + "|" + mathMetrics;
-
-  const algorithm = opts.hash === "sha512" ? "SHA-512" : "SHA-256";
-  const hash = await crypto.subtle.digest(
-    algorithm,
-    new TextEncoder().encode(combined),
-  );
-
-  let fingerprint = Array.from(new Uint8Array(hash))
-    .map((b) => b.toString(16).padStart(2, "0"))
-    .join("");
-
-  if (opts.gpuBenchmark) {
-    const gpuHash = await getGPUHash();
-    fingerprint = Array.from(new Uint8Array(
-      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(fingerprint + gpuHash))
-    ))
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("");
-  }
-
-  if (opts.cpuBenchmark) {
-    const cpuHash = await getCPUHash();
-    fingerprint = Array.from(new Uint8Array(
-      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(fingerprint + cpuHash))
-    ))
-      .map((b) => b.toString(16).padStart(2, "0"))
-      .join("");
-  }
-
-  if (opts.detailed) {
-    const os = await getOSVersionEntropy();
-    const lang = await getLanguageEntropy();
-    const tz = await getTimezoneEntropy();
-    const hw = await getHardwareEntropy();
-    const sr = await getScreenInfoEntropy();
-    const ua = await getUserAgentEntropy();
-    const browser = await getBrowserEntropy();
-
-    const sourceMetrics: SourceMetric[] = sources.map(s => ({
-      source: s.name,
-      value: s.value,
-      entropy: s.entropy,
-      confidence: score.likelihood > 0 ? Math.min(s.entropy / score.likelihood, 1) : 0,
-    }));
-
-    const response: FingerprintResponse = {
-      hash: fingerprint,
-      uniqueness: score.uniqueness,
-      confidence: score.confidence,
-      sources: sourceMetrics,
-      system: {
-        os,
-        language: lang.split("|")[0],
-        timezone: tz.split("|")[0],
-        hardware: {
-          cores: navigator.hardwareConcurrency || 0,
-          memory: (navigator as any).deviceMemory || 0,
-        },
-      },
-      display: {
-        resolution: `${screen.width}x${screen.height}`,
-        colorDepth: screen.colorDepth,
-        devicePixelRatio: window.devicePixelRatio,
-      },
-      browser: {
-        userAgent: navigator.userAgent,
-        vendor: navigator.vendor,
-        cookieEnabled: navigator.cookieEnabled,
-      },
-    };
-
-    return response;
-  }
-
-  return fingerprint;
-}
-
-export type { FingerprintOptions, FingerprintResponse } from "./types";

package/src/normalize/index.ts

@@ -1,31 +0,0 @@
-export function normalizeScreen(width: number, height: number): string {
-  const bucketSize = 100;
-  const bw = Math.floor(width / bucketSize) * bucketSize;
-  const bh = Math.floor(height / bucketSize) * bucketSize;
-  return `${bw}x${bh}`;
-}
-
-export function normalizeTimezone(tz: string): string {
-  return tz.split("/")[0];
-}
-
-export function normalizeUserAgent(ua: string): string {
-  const parts = ua.split(" ");
-  return parts.slice(0, 3).join(" ");
-}
-
-export function normalizeFloat(num: number, decimals: number = 10): string {
-  return num.toFixed(decimals);
-}
-
-export function normalizeCanvas(dataUrl: string): string {
-  return dataUrl.substring(0, 100);
-}
-
-export function normalizeStorage(storageStr: string): string {
-  const [localStorage, indexedDB] = storageStr.split("|");
-  const ls = localStorage.includes("true") ? "1" : "0";
-  const idb = indexedDB.includes("true") ? "1" : "0";
-
-  return `${ls}${idb}`;
-}

package/src/probability.ts

@@ -1,11 +0,0 @@
-export function calculateMean(values: number[]): number {
-  if (values.length === 0) return 0;
-  return values.reduce((a, b) => a + b, 0) / values.length;
-}
-
-export function hellingerDistance(p: number[], q: number[]): number {
-  if (p.length !== q.length) return 0;
-  
-  const sum = p.reduce((s, pi, i) => s + Math.pow(Math.sqrt(pi) - Math.sqrt(q[i]), 2), 0);
-  return Math.sqrt(sum / 2);
-}

package/src/scoring.ts

@@ -1,106 +0,0 @@
-import { calculateMean, hellingerDistance } from "./probability";
-
-export interface EntropySource {
-  name: string;
-  value: string;
-  entropy: number;
-}
-
-export interface FingerprintScore {
-  likelihood: number;
-  confidence: number;
-  uniqueness: number;
-  divergence: number;
-  sources: EntropySource[];
-}
-
-export function calculateEntropy(data: string): number {
-  const freq: Record<string, number> = {};
-  for (const char of data) {
-    freq[char] = (freq[char] || 0) + 1;
-  }
-
-  let entropy = 0;
-  for (const count of Object.values(freq)) {
-    const p = count / data.length;
-    if (p > 0) {
-      entropy -= p * Math.log2(p);
-    }
-  }
-  return entropy;
-}
-
-export function calculateLikelihood(sources: EntropySource[]): number {
-  const entropies = sources.map(s => s.entropy).filter(e => !isNaN(e) && e > 0);
-  
-  if (entropies.length === 0) return 0;
-
-  const mean = entropies.reduce((a, b) => a + b) / entropies.length;
-  const variance = entropies.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / entropies.length;
-  const stdDev = Math.sqrt(variance);
-
-  return mean * (1 + stdDev / mean);
-}
-
-export function calculateConfidence(sources: EntropySource[], likelihood: number): number {
-  const maxPossibleEntropy = Math.log2(256);
-  const sourceCount = sources.length;
-  
-  const normalizedLikelihood = Math.min(likelihood / maxPossibleEntropy, 1);
-  const sourceWeighting = Math.log2(sourceCount + 1) / Math.log2(32);
-  
-  return normalizedLikelihood * sourceWeighting;
-}
-
-export function calculateUniqueness(sources: EntropySource[], likelihood: number, confidence: number): number {
-  const distinctSources = new Set(sources.map(s => s.value)).size;
-  const totalSources = sources.length;
-  const diversity = distinctSources / totalSources;
-  
-  const informationContent = likelihood * Math.log2(totalSources);
-  const uniquenessScore = informationContent * confidence * diversity;
-  
-  return Math.min(uniquenessScore / 100, 0.999);
-}
-
-export function scoreFingerprint(sources: EntropySource[]): FingerprintScore {
-  const likelihood = calculateLikelihood(sources);
-  const confidence = calculateConfidence(sources, likelihood);
-  const uniqueness = calculateUniqueness(sources, likelihood, confidence);
-  
-  const entropies = sources.map(s => s.entropy).filter(e => !isNaN(e) && e > 0);
-  const uniformDist = new Array(entropies.length).fill(1 / entropies.length);
-  const normalizedEntropies = entropies.length > 0 
-    ? entropies.map(e => e / calculateMean(entropies))
-    : [];
-  
-  const divergence = normalizedEntropies.length > 0 
-    ? hellingerDistance(normalizedEntropies, uniformDist.slice(0, normalizedEntropies.length))
-    : 0;
-
-  return {
-    likelihood,
-    confidence,
-    uniqueness,
-    divergence,
-    sources,
-  };
-}
-
-export function bayesianCombine(sources: EntropySource[]): Record<string, number> {
-  const score = scoreFingerprint(sources);
-  
-  const weights: Record<string, number> = {};
-  const totalEntropy = sources.reduce((sum, s) => sum + (s.entropy || 0), 0);
-
-  for (const source of sources) {
-    const sourceEntropy = source.entropy || 0;
-    const prior = 1 / sources.length;
-    const likelihood = sourceEntropy / (totalEntropy || 1);
-    const posterior = (likelihood * prior) / score.likelihood;
-    
-    weights[source.name] = posterior;
-  }
-
-  return weights;
-}

package/src/seeded-rng.ts

@@ -1,14 +0,0 @@
-export function seededRng(seed: string, count: number): number[] {
-  let hash = 5381;
-  for (let i = 0; i < seed.length; i++) {
-    hash = ((hash << 5) + hash) ^ seed.charCodeAt(i);
-  }
-  
-  const samples: number[] = [];
-  for (let i = 0; i < count; i++) {
-    hash = (hash * 1103515245 + 12345) & 0x7fffffff;
-    samples.push(hash / 0x7fffffff);
-  }
-  
-  return samples;
-}

package/src/types/index.ts

@@ -1,11 +0,0 @@
-export interface FingerprintOptions {
-  entropy: {
-    userAgent?: boolean;
-    canvas?: boolean;
-    webgl?: boolean;
-    fonts?: boolean;
-    storage?: boolean;
-    screen?: boolean;
-  };
-  hash?: "sha256" | "sha512";
-}

package/src/types.ts

@@ -1,47 +0,0 @@
-export interface FingerprintOptions {
-  entropy: {
-    userAgent?: boolean;
-    canvas?: boolean;
-    webgl?: boolean;
-    fonts?: boolean;
-    storage?: boolean;
-    screen?: boolean;
-  };
-  hash?: "sha256" | "sha512";
-  detailed?: boolean;
-  gpuBenchmark?: boolean;
-  cpuBenchmark?: boolean;
-}
-
-export interface SourceMetric {
-  source: string;
-  value: string;
-  entropy: number;
-  confidence: number;
-}
-
-export interface FingerprintResponse {
-  hash: string;
-  uniqueness: number;
-  confidence: number;
-  sources: SourceMetric[];
-  system: {
-    os: string;
-    language: string;
-    timezone: string;
-    hardware: {
-      cores: number;
-      memory: number;
-    };
-  };
-  display: {
-    resolution: string;
-    colorDepth: number;
-    devicePixelRatio: number;
-  };
-  browser: {
-    userAgent: string;
-    vendor: string;
-    cookieEnabled: boolean;
-  };
-}

package/src/veil_core.d.ts

@@ -1,4 +0,0 @@
-export function fnv_hash(s: string): string;
-export function kolmogorov_complexity(s: string): number;
-export function murmur_hash(s: string): string;
-export function shannon_entropy(s: string): number;