import { verifyFetch } from 'verifyfetch';

const response = await verifyFetch('/model.bin', {
  sri: 'sha256-uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek='
});

import { verifyFetch } from 'verifyfetch';

const response = await verifyFetch('/engine.wasm', {
  sri: 'sha256-uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek='
});

// sw.js (your Service Worker)
import { createVerifyWorker } from 'verifyfetch/worker';

createVerifyWorker({
  manifestUrl: '/vf.manifest.json',
  include: ['*.wasm', '*.bin', '*.onnx', '*.safetensors'],
  onFail: 'block'
});

// app.js - No changes needed!
const model = await fetch('/model.bin');  // Automatically verified!

import { createVerifyFetcher } from 'verifyfetch';

const vf = await createVerifyFetcher({
  manifestUrl: '/vf.manifest.json'
});

const wasm = await vf.arrayBuffer('/engine.wasm');  // Hash looked up automatically

import { verifyFetchResumable } from 'verifyfetch';

const model = await verifyFetchResumable('/phi-3-mini.gguf', {
  chunked: manifest.artifacts['/phi-3-mini.gguf'].chunked,
  persist: true,  // Survives page reload
  onProgress: ({ percent, resumed }) => {
    console.log(`${percent}%${resumed ? ' (resumed)' : ''}`);
  }
});

import { verifyFetchStream } from 'verifyfetch';

const { stream, verified } = await verifyFetchStream('/model.bin', {
  sri: 'sha256-...'
});

// Process chunks immediately - constant memory usage
for await (const chunk of stream) {
  await uploadToGPU(chunk);
}

// Verification completes after stream ends
await verified;  // Throws IntegrityError if hash doesn't match

import { verifyFetchResumable } from 'verifyfetch';

// First attempt - fails at 80%
const result = await verifyFetchResumable('/model.safetensors', {
  chunked: manifest.artifacts['/model.safetensors'].chunked,
  onProgress: ({ chunksVerified, totalChunks, resumed }) => {
    console.log(`${chunksVerified}/${totalChunks} chunks${resumed ? ' (resumed)' : ''}`);
  }
});

// Page reload or network failure...

// Second attempt - automatically resumes from last verified chunk
const result2 = await verifyFetchResumable('/model.safetensors', {
  chunked: manifest.artifacts['/model.safetensors'].chunked,
  onResume: (state) => {
    console.log(`Resuming from chunk ${state.verifiedChunks}/${totalChunks}`);
  }
});

import { createChunkedVerifier, verifyFetchStream } from 'verifyfetch';

// Generate manifest with chunked hashes
// npx verifyfetch sign --chunked ./large-model.bin

// Verify chunk-by-chunk as data arrives
const verifier = createChunkedVerifier(manifest.artifacts['/model.bin'].chunked);

const { stream } = await verifyFetchStream('/model.bin', { sri: chunked.root });

for await (const chunk of stream) {
  const result = await verifier.verifyNextChunk(chunk);

  if (!result.valid) {
    // Don't download 4GB if byte 0 is wrong!
    throw new Error(`Chunk ${result.index} corrupt - stopping immediately`);
  }

  await processChunk(chunk);
}

import { verifyFetchFromSources } from 'verifyfetch';

const response = await verifyFetchFromSources(
  'sha256-abc123...',
  '/model.bin',
  {
    sources: [
      'https://cdn1.example.com',
      'https://cdn2.example.com',
      'https://backup.example.com'
    ],
    strategy: 'race'  // 'sequential' | 'race' | 'fastest'
  }
);

await verifyFetch('/large-model.bin', {
  sri: 'sha256-...',
  onProgress: (bytes, total) => {
    const percent = total ? Math.round(bytes / total * 100) : 0;
    console.log(`Downloading: ${percent}%`);
  }
});

await verifyFetch('/main.wasm', {
  sri: 'sha256-...',
  onFail: { fallbackUrl: '/backup.wasm' }
});

const response = await verifyFetch('/file.bin', {
  sri: 'sha256-...',              // Required: SRI hash
  onFail: 'block',                // 'block' | 'warn' | { fallbackUrl }
  onProgress: (bytes, total) => {},
  fetchImpl: fetch                // Custom fetch implementation
});

const { stream, verified, totalBytes } = await verifyFetchStream('/file.bin', {
  sri: 'sha256-...',
  onProgress: (bytes, total) => {}
});

for await (const chunk of stream) {
  // Process immediately
}

await verified;  // Throws if verification fails

const response = await verifyFetchFromSources(
  'sha256-...',
  '/file.bin',
  {
    sources: ['https://cdn1.com', 'https://cdn2.com'],
    strategy: 'sequential',       // 'sequential' | 'race' | 'fastest'
    timeout: 30000,
    onSourceError: (source, error) => {}
  }
);

const vf = await createVerifyFetcher({
  manifestUrl: '/vf.manifest.json',
  baseUrl: 'https://cdn.example.com'  // Optional
});

await vf.arrayBuffer('/file.wasm');
await vf.json('/config.json');
await vf.text('/data.txt');

// In sw.js
import { createVerifyWorker } from 'verifyfetch/worker';

createVerifyWorker({
  manifestUrl: '/vf.manifest.json',
  include: ['*.wasm', '*.bin', '*.onnx'],
  exclude: ['*.json'],
  onFail: 'block',                // 'block' | 'warn' | 'passthrough'
  cacheVerified: true,
  cacheName: 'verifyfetch-verified',
  debug: false
});

const result = await verifyFetchResumable('/model.bin', {
  chunked: manifest.artifacts['/model.bin'].chunked, // Required
  persist: true,                    // Store progress in IndexedDB (default: true)
  onProgress: ({ bytesVerified, totalBytes, chunksVerified, totalChunks, resumed, speed, eta }) => {},
  onResume: (state) => {},          // Called when resuming
  chunkTimeout: 30000               // Timeout per chunk request
});

// result: { data: ArrayBuffer, resumed: boolean, chunksResumed: number, totalChunks: number }

import { canResume, getDownloadProgress, cancelDownload } from 'verifyfetch';

// Check if a download can be resumed
const resumable = await canResume('/model.bin');

// Get progress of paused download
const progress = await getDownloadProgress('/model.bin');
// { chunksVerified, totalChunks, bytesVerified, totalBytes, startedAt, lastUpdated }

// Cancel and clear a download
await cancelDownload('/model.bin');

import { generateChunkedHashes, createChunkedVerifier, verifyChunk } from 'verifyfetch';

// Generate chunk hashes from data
const chunked = await generateChunkedHashes(data, 1048576); // 1MB chunks
// { root: 'sha256-...', chunkSize: 1048576, hashes: ['sha256-...', ...] }

// Create verifier for streaming
const verifier = createChunkedVerifier(chunked);
const result = await verifier.verifyNextChunk(chunk);
// { valid: boolean, index: number }

// Verify single chunk
const isValid = await verifyChunk(chunk, 'sha256-...');