@eudi-verify/client 0.1.0

package/dist/index.js

@@ -0,0 +1,772 @@
+// src/types.ts
+var TERMINAL_STATUSES = Object.freeze([
+  "verified",
+  "rejected",
+  "expired",
+  "cancelled",
+  "error"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.includes(status);
+}
+
+// src/errors.ts
+var EudiClientError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EudiClientError";
+  }
+};
+var NetworkError = class extends EudiClientError {
+  cause;
+  constructor(message, cause) {
+    super(message);
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+};
+var ApiResponseError = class extends EudiClientError {
+  statusCode;
+  errorCode;
+  details;
+  constructor(statusCode, response) {
+    super(response.message);
+    this.name = "ApiResponseError";
+    this.statusCode = statusCode;
+    this.errorCode = response.error;
+    this.details = response.details;
+  }
+};
+var SessionNotFoundError = class extends ApiResponseError {
+  sessionId;
+  constructor(sessionId) {
+    super(404, { error: "not_found", message: `Session ${sessionId} not found` });
+    this.name = "SessionNotFoundError";
+    this.sessionId = sessionId;
+  }
+};
+var RateLimitError = class extends ApiResponseError {
+  retryAfterMs;
+  constructor(retryAfterMs) {
+    super(429, { error: "rate_limit", message: "Rate limit exceeded" });
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var VerificationCancelledError = class extends EudiClientError {
+  constructor() {
+    super("Verification was cancelled");
+    this.name = "VerificationCancelledError";
+  }
+};
+var SessionExpiredError = class extends EudiClientError {
+  constructor() {
+    super("Session expired");
+    this.name = "SessionExpiredError";
+  }
+};
+
+// src/api.ts
+function createApiClient(config) {
+  const { baseUrl, timeoutMs = 3e4 } = config;
+  const fetchFn = config.fetch ?? fetch;
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  async function request(method, path, body) {
+    const url = `${normalizedBaseUrl}${path}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetchFn(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        await handleErrorResponse(response, path);
+      }
+      const data = await response.json();
+      return data;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ApiResponseError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          throw new NetworkError(`Request timeout after ${timeoutMs}ms`);
+        }
+        throw new NetworkError(`Network request failed: ${error.message}`, error);
+      }
+      throw new NetworkError("Unknown network error");
+    }
+  }
+  async function handleErrorResponse(response, path) {
+    const { status } = response;
+    if (status === 404) {
+      const sessionIdMatch = path.match(/\/sessions\/([^/]+)/);
+      if (sessionIdMatch) {
+        throw new SessionNotFoundError(sessionIdMatch[1]);
+      }
+    }
+    if (status === 429) {
+      const retryAfter = response.headers.get("Retry-After");
+      const retryAfterMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : void 0;
+      throw new RateLimitError(retryAfterMs);
+    }
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+      errorBody = {
+        error: "unknown_error",
+        message: `HTTP ${status}`
+      };
+    }
+    throw new ApiResponseError(status, errorBody);
+  }
+  return {
+    async createSession(verificationRequest) {
+      return request("POST", "/sessions", { request: verificationRequest });
+    },
+    async getSession(sessionId) {
+      return request("GET", `/sessions/${encodeURIComponent(sessionId)}`);
+    },
+    async cancelSession(sessionId) {
+      return request(
+        "POST",
+        `/sessions/${encodeURIComponent(sessionId)}/cancel`
+      );
+    }
+  };
+}
+
+// src/polling.ts
+var DEFAULT_CONFIG = {
+  initialIntervalMs: 1e3,
+  maxIntervalMs: 1e4,
+  backoffMultiplier: 2
+};
+function createPoller(fn, config = {}) {
+  const { initialIntervalMs, maxIntervalMs, backoffMultiplier } = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  let currentInterval = initialIntervalMs;
+  let timeoutId = null;
+  let running = false;
+  async function poll() {
+    if (!running) return;
+    try {
+      const shouldStop = await fn();
+      if (shouldStop || !running) {
+        running = false;
+        return;
+      }
+    } catch {
+    }
+    if (!running) return;
+    currentInterval = Math.min(
+      currentInterval * backoffMultiplier,
+      maxIntervalMs
+    );
+    timeoutId = setTimeout(() => {
+      void poll();
+    }, currentInterval);
+  }
+  return {
+    start() {
+      if (running) return;
+      running = true;
+      currentInterval = initialIntervalMs;
+      void poll();
+    },
+    stop() {
+      running = false;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    },
+    reset() {
+      currentInterval = initialIntervalMs;
+    }
+  };
+}
+
+// src/qr.ts
+var EC_LEVELS = { L: 0, M: 1, Q: 2, H: 3 };
+var VERSION_TABLE = {
+  L: [
+    { version: 1, totalCodewords: 19, ecCodewordsPerBlock: 7, numBlocks: 1 },
+    { version: 2, totalCodewords: 34, ecCodewordsPerBlock: 10, numBlocks: 1 },
+    { version: 3, totalCodewords: 55, ecCodewordsPerBlock: 15, numBlocks: 1 },
+    { version: 4, totalCodewords: 80, ecCodewordsPerBlock: 20, numBlocks: 1 },
+    { version: 5, totalCodewords: 108, ecCodewordsPerBlock: 26, numBlocks: 1 },
+    { version: 6, totalCodewords: 136, ecCodewordsPerBlock: 18, numBlocks: 2 },
+    { version: 7, totalCodewords: 156, ecCodewordsPerBlock: 20, numBlocks: 2 },
+    { version: 8, totalCodewords: 194, ecCodewordsPerBlock: 24, numBlocks: 2 },
+    { version: 9, totalCodewords: 232, ecCodewordsPerBlock: 30, numBlocks: 2 },
+    { version: 10, totalCodewords: 274, ecCodewordsPerBlock: 18, numBlocks: 4 },
+    { version: 11, totalCodewords: 401, ecCodewordsPerBlock: 20, numBlocks: 4 },
+    { version: 12, totalCodewords: 466, ecCodewordsPerBlock: 24, numBlocks: 4 },
+    { version: 13, totalCodewords: 532, ecCodewordsPerBlock: 26, numBlocks: 4 },
+    { version: 14, totalCodewords: 588, ecCodewordsPerBlock: 30, numBlocks: 4 }
+  ],
+  M: [
+    { version: 1, totalCodewords: 16, ecCodewordsPerBlock: 10, numBlocks: 1 },
+    { version: 2, totalCodewords: 28, ecCodewordsPerBlock: 16, numBlocks: 1 },
+    { version: 3, totalCodewords: 44, ecCodewordsPerBlock: 26, numBlocks: 1 },
+    { version: 4, totalCodewords: 64, ecCodewordsPerBlock: 18, numBlocks: 2 },
+    { version: 5, totalCodewords: 86, ecCodewordsPerBlock: 24, numBlocks: 2 },
+    { version: 6, totalCodewords: 108, ecCodewordsPerBlock: 16, numBlocks: 4 },
+    { version: 7, totalCodewords: 124, ecCodewordsPerBlock: 18, numBlocks: 4 },
+    { version: 8, totalCodewords: 154, ecCodewordsPerBlock: 22, numBlocks: 4 },
+    { version: 9, totalCodewords: 182, ecCodewordsPerBlock: 22, numBlocks: 5 },
+    { version: 10, totalCodewords: 216, ecCodewordsPerBlock: 26, numBlocks: 5 }
+  ],
+  Q: [
+    { version: 1, totalCodewords: 13, ecCodewordsPerBlock: 13, numBlocks: 1 },
+    { version: 2, totalCodewords: 22, ecCodewordsPerBlock: 22, numBlocks: 1 },
+    { version: 3, totalCodewords: 34, ecCodewordsPerBlock: 18, numBlocks: 2 },
+    { version: 4, totalCodewords: 48, ecCodewordsPerBlock: 26, numBlocks: 2 },
+    { version: 5, totalCodewords: 62, ecCodewordsPerBlock: 18, numBlocks: 4 },
+    { version: 6, totalCodewords: 76, ecCodewordsPerBlock: 24, numBlocks: 4 },
+    { version: 7, totalCodewords: 88, ecCodewordsPerBlock: 18, numBlocks: 6 },
+    { version: 8, totalCodewords: 110, ecCodewordsPerBlock: 22, numBlocks: 6 },
+    { version: 9, totalCodewords: 132, ecCodewordsPerBlock: 20, numBlocks: 8 },
+    { version: 10, totalCodewords: 154, ecCodewordsPerBlock: 24, numBlocks: 8 }
+  ],
+  H: [
+    { version: 1, totalCodewords: 9, ecCodewordsPerBlock: 17, numBlocks: 1 },
+    { version: 2, totalCodewords: 16, ecCodewordsPerBlock: 28, numBlocks: 1 },
+    { version: 3, totalCodewords: 26, ecCodewordsPerBlock: 22, numBlocks: 2 },
+    { version: 4, totalCodewords: 36, ecCodewordsPerBlock: 16, numBlocks: 4 },
+    { version: 5, totalCodewords: 46, ecCodewordsPerBlock: 22, numBlocks: 4 },
+    { version: 6, totalCodewords: 60, ecCodewordsPerBlock: 28, numBlocks: 4 },
+    { version: 7, totalCodewords: 66, ecCodewordsPerBlock: 26, numBlocks: 5 },
+    { version: 8, totalCodewords: 86, ecCodewordsPerBlock: 26, numBlocks: 6 },
+    { version: 9, totalCodewords: 100, ecCodewordsPerBlock: 24, numBlocks: 8 },
+    { version: 10, totalCodewords: 122, ecCodewordsPerBlock: 28, numBlocks: 8 }
+  ]
+};
+var FORMAT_INFO_STRINGS = {
+  0: [1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0],
+  1: [1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1],
+  2: [1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0],
+  3: [1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1],
+  4: [1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1],
+  5: [1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0],
+  6: [1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1],
+  7: [1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0],
+  8: [1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0],
+  9: [1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1],
+  10: [1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0],
+  11: [1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1],
+  12: [1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1],
+  13: [1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0],
+  14: [1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1],
+  15: [1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0],
+  16: [0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1],
+  17: [0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0],
+  18: [0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1],
+  19: [0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0],
+  20: [0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0],
+  21: [0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1],
+  22: [0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0],
+  23: [0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1],
+  24: [0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1],
+  25: [0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0],
+  26: [0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1],
+  27: [0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0],
+  28: [0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0],
+  29: [0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1],
+  30: [0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0],
+  31: [0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1]
+};
+var ALIGNMENT_PATTERNS = [
+  [],
+  [],
+  [6, 18],
+  [6, 22],
+  [6, 26],
+  [6, 30],
+  [6, 34],
+  [6, 22, 38],
+  [6, 24, 42],
+  [6, 26, 46],
+  [6, 28, 50],
+  [6, 30, 54],
+  [6, 32, 58],
+  [6, 34, 62],
+  [6, 26, 46, 66]
+];
+function getVersionInfo(dataLength, ecLevel) {
+  const table = VERSION_TABLE[ecLevel];
+  for (const info of table) {
+    const dataCodewords = info.totalCodewords - info.ecCodewordsPerBlock * info.numBlocks;
+    const maxBytes = dataCodewords - (info.version < 10 ? 2 : 3);
+    if (maxBytes >= dataLength) {
+      return info;
+    }
+  }
+  throw new Error(`Data too long for QR code (max ~270 bytes with ${ecLevel} EC)`);
+}
+function createByteData(data, version) {
+  const bytes = new TextEncoder().encode(data);
+  const bits = [];
+  bits.push(0, 1, 0, 0);
+  const countBits = version < 10 ? 8 : 16;
+  for (let i = countBits - 1; i >= 0; i--) {
+    bits.push(bytes.length >> i & 1);
+  }
+  for (const byte of bytes) {
+    for (let i = 7; i >= 0; i--) {
+      bits.push(byte >> i & 1);
+    }
+  }
+  bits.push(0, 0, 0, 0);
+  while (bits.length % 8 !== 0) {
+    bits.push(0);
+  }
+  const codewords = [];
+  for (let i = 0; i < bits.length; i += 8) {
+    let byte = 0;
+    for (let j = 0; j < 8; j++) {
+      byte = byte << 1 | (bits[i + j] ?? 0);
+    }
+    codewords.push(byte);
+  }
+  return codewords;
+}
+var GF_EXP = new Uint8Array(512);
+var GF_LOG = new Uint8Array(256);
+(function initGaloisField() {
+  let x = 1;
+  for (let i = 0; i < 255; i++) {
+    GF_EXP[i] = x;
+    GF_LOG[x] = i;
+    x <<= 1;
+    if (x & 256) x ^= 285;
+  }
+  for (let i = 255; i < 512; i++) {
+    GF_EXP[i] = GF_EXP[i - 255];
+  }
+})();
+function gfMul(a, b) {
+  if (a === 0 || b === 0) return 0;
+  return GF_EXP[GF_LOG[a] + GF_LOG[b]];
+}
+function generateECCodewords(data, numECCodewords) {
+  const gen = [1];
+  for (let i = 0; i < numECCodewords; i++) {
+    const newGen = new Array(gen.length + 1).fill(0);
+    for (let j = 0; j < gen.length; j++) {
+      newGen[j] ^= gen[j];
+      newGen[j + 1] ^= gfMul(gen[j], GF_EXP[i]);
+    }
+    gen.length = newGen.length;
+    for (let j = 0; j < newGen.length; j++) gen[j] = newGen[j];
+  }
+  const msg = [...data, ...new Array(numECCodewords).fill(0)];
+  for (let i = 0; i < data.length; i++) {
+    const coef = msg[i];
+    if (coef !== 0) {
+      for (let j = 0; j < gen.length; j++) {
+        msg[i + j] ^= gfMul(gen[j], coef);
+      }
+    }
+  }
+  return msg.slice(data.length);
+}
+function interleaveBlocks(dataCodewords, info) {
+  const { numBlocks, ecCodewordsPerBlock, totalCodewords } = info;
+  const totalDataCodewords = totalCodewords - numBlocks * ecCodewordsPerBlock;
+  const smallBlockSize = Math.floor(totalDataCodewords / numBlocks);
+  const largeBlockCount = totalDataCodewords % numBlocks;
+  const dataBlocks = [];
+  const ecBlocks = [];
+  let offset = 0;
+  for (let i = 0; i < numBlocks; i++) {
+    const blockSize = smallBlockSize + (i >= numBlocks - largeBlockCount ? 1 : 0);
+    const block = dataCodewords.slice(offset, offset + blockSize);
+    offset += blockSize;
+    dataBlocks.push(block);
+    ecBlocks.push(generateECCodewords(block, ecCodewordsPerBlock));
+  }
+  const result = [];
+  const maxDataLen = Math.max(...dataBlocks.map((b) => b.length));
+  for (let i = 0; i < maxDataLen; i++) {
+    for (const block of dataBlocks) {
+      if (i < block.length) result.push(block[i]);
+    }
+  }
+  for (let i = 0; i < ecCodewordsPerBlock; i++) {
+    for (const block of ecBlocks) {
+      result.push(block[i]);
+    }
+  }
+  return result;
+}
+function createMatrix(version) {
+  const size = version * 4 + 17;
+  const matrix = Array.from(
+    { length: size },
+    () => new Array(size).fill(null)
+  );
+  function setFinderPattern(row, col) {
+    for (let r = -1; r <= 7; r++) {
+      for (let c = -1; c <= 7; c++) {
+        const nr = row + r;
+        const nc = col + c;
+        if (nr < 0 || nr >= size || nc < 0 || nc >= size) continue;
+        const isOuter = r === -1 || r === 7 || c === -1 || c === 7;
+        const isInner = r >= 1 && r <= 5 && c >= 1 && c <= 5;
+        const isCore = r >= 2 && r <= 4 && c >= 2 && c <= 4;
+        matrix[nr][nc] = isOuter ? 0 : isCore ? 1 : isInner ? 0 : 1;
+      }
+    }
+  }
+  setFinderPattern(0, 0);
+  setFinderPattern(0, size - 7);
+  setFinderPattern(size - 7, 0);
+  for (let i = 8; i < size - 8; i++) {
+    matrix[6][i] = i % 2 === 0 ? 1 : 0;
+    matrix[i][6] = i % 2 === 0 ? 1 : 0;
+  }
+  matrix[size - 8][8] = 1;
+  if (version >= 2) {
+    const positions = ALIGNMENT_PATTERNS[version];
+    for (const row of positions) {
+      for (const col of positions) {
+        if (matrix[row][col] !== null) continue;
+        for (let r = -2; r <= 2; r++) {
+          for (let c = -2; c <= 2; c++) {
+            const isOuter = Math.abs(r) === 2 || Math.abs(c) === 2;
+            const isCore = r === 0 && c === 0;
+            matrix[row + r][col + c] = isOuter || isCore ? 1 : 0;
+          }
+        }
+      }
+    }
+  }
+  return matrix;
+}
+function placeData(matrix, codewords) {
+  const size = matrix.length;
+  let bitIndex = 0;
+  const bits = [];
+  for (const cw of codewords) {
+    for (let i = 7; i >= 0; i--) {
+      bits.push(cw >> i & 1);
+    }
+  }
+  let col = size - 1;
+  let goingUp = true;
+  while (col > 0) {
+    if (col === 6) col--;
+    for (let row = goingUp ? size - 1 : 0; goingUp ? row >= 0 : row < size; row += goingUp ? -1 : 1) {
+      for (const offset of [0, -1]) {
+        const c = col + offset;
+        if (c < 0 || matrix[row][c] !== null) continue;
+        matrix[row][c] = bitIndex < bits.length ? bits[bitIndex++] : 0;
+      }
+    }
+    col -= 2;
+    goingUp = !goingUp;
+  }
+}
+function applyMask(matrix, maskPattern) {
+  const size = matrix.length;
+  const maskFns = [
+    (r, c) => (r + c) % 2 === 0,
+    (r) => r % 2 === 0,
+    (_, c) => c % 3 === 0,
+    (r, c) => (r + c) % 3 === 0,
+    (r, c) => (Math.floor(r / 2) + Math.floor(c / 3)) % 2 === 0,
+    (r, c) => r * c % 2 + r * c % 3 === 0,
+    (r, c) => (r * c % 2 + r * c % 3) % 2 === 0,
+    (r, c) => ((r + c) % 2 + r * c % 3) % 2 === 0
+  ];
+  const maskFn = maskFns[maskPattern];
+  const reserved = createReservedMask(size);
+  for (let r = 0; r < size; r++) {
+    for (let c = 0; c < size; c++) {
+      if (!reserved[r][c] && maskFn(r, c)) {
+        matrix[r][c] ^= 1;
+      }
+    }
+  }
+}
+function createReservedMask(size) {
+  const reserved = Array.from(
+    { length: size },
+    () => new Array(size).fill(false)
+  );
+  for (let i = 0; i < 8; i++) {
+    for (let j = 0; j < 8; j++) {
+      reserved[i][j] = true;
+      reserved[i][size - 8 + j] = true;
+      reserved[size - 8 + i][j] = true;
+    }
+  }
+  for (let i = 0; i < 9; i++) {
+    reserved[i][8] = true;
+    reserved[8][i] = true;
+    reserved[size - 8 + i - 1][8] = true;
+    reserved[8][size - 8 + i - 1] = true;
+  }
+  for (let i = 0; i < size; i++) {
+    reserved[6][i] = true;
+    reserved[i][6] = true;
+  }
+  return reserved;
+}
+function addFormatInfo(matrix, ecLevel, maskPattern) {
+  const formatIndex = EC_LEVELS[ecLevel] * 8 + maskPattern;
+  const bits = FORMAT_INFO_STRINGS[formatIndex];
+  const size = matrix.length;
+  for (let i = 0; i < 6; i++) {
+    matrix[8][i] = bits[i];
+    matrix[i][8] = bits[14 - i];
+  }
+  matrix[8][7] = bits[6];
+  matrix[8][8] = bits[7];
+  matrix[7][8] = bits[8];
+  for (let i = 0; i < 7; i++) {
+    matrix[8][size - 1 - i] = bits[14 - i];
+    matrix[size - 1 - i][8] = bits[i];
+  }
+  matrix[size - 8][8] = bits[7];
+}
+function evaluatePenalty(matrix) {
+  const size = matrix.length;
+  let penalty = 0;
+  for (let r = 0; r < size; r++) {
+    let count = 1;
+    for (let c = 1; c < size; c++) {
+      if (matrix[r][c] === matrix[r][c - 1]) {
+        count++;
+        if (count === 5) penalty += 3;
+        else if (count > 5) penalty++;
+      } else {
+        count = 1;
+      }
+    }
+  }
+  for (let c = 0; c < size; c++) {
+    let count = 1;
+    for (let r = 1; r < size; r++) {
+      if (matrix[r][c] === matrix[r - 1][c]) {
+        count++;
+        if (count === 5) penalty += 3;
+        else if (count > 5) penalty++;
+      } else {
+        count = 1;
+      }
+    }
+  }
+  return penalty;
+}
+function generateQRMatrix(data, ecLevel) {
+  const info = getVersionInfo(data.length, ecLevel);
+  const dataCodewords = createByteData(data, info.version);
+  const totalDataCodewords = info.totalCodewords - info.numBlocks * info.ecCodewordsPerBlock;
+  while (dataCodewords.length < totalDataCodewords) {
+    dataCodewords.push(dataCodewords.length % 2 === 0 ? 236 : 17);
+  }
+  const codewords = interleaveBlocks(dataCodewords, info);
+  const baseMatrix = createMatrix(info.version);
+  placeData(baseMatrix, codewords);
+  let bestMatrix = null;
+  let bestPenalty = Infinity;
+  for (let mask = 0; mask < 8; mask++) {
+    const matrix = baseMatrix.map(
+      (row) => row.map((cell) => cell === null ? 0 : cell)
+    );
+    applyMask(matrix, mask);
+    addFormatInfo(matrix, ecLevel, mask);
+    const penalty = evaluatePenalty(matrix);
+    if (penalty < bestPenalty) {
+      bestPenalty = penalty;
+      bestMatrix = matrix;
+    }
+  }
+  return bestMatrix;
+}
+function generateQRSvg(data, options = {}) {
+  const { size = 200, errorCorrection = "L", quietZone = 4 } = options;
+  const matrix = generateQRMatrix(data, errorCorrection);
+  const moduleCount = matrix.length;
+  const totalModules = moduleCount + quietZone * 2;
+  const moduleSize = size / totalModules;
+  let paths = "";
+  for (let r = 0; r < moduleCount; r++) {
+    for (let c = 0; c < moduleCount; c++) {
+      if (matrix[r][c] === 1) {
+        const x = (c + quietZone) * moduleSize;
+        const y = (r + quietZone) * moduleSize;
+        paths += `M${x},${y}h${moduleSize}v${moduleSize}h-${moduleSize}z`;
+      }
+    }
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" width="${size}" height="${size}"><rect width="100%" height="100%" fill="white"/><path d="${paths}" fill="black"/></svg>`;
+}
+function generateQRDataUrl(data, options = {}) {
+  const svg = generateQRSvg(data, options);
+  const encoded = encodeURIComponent(svg).replace(/'/g, "%27").replace(/"/g, "%22");
+  return `data:image/svg+xml,${encoded}`;
+}
+
+// src/verification.ts
+function createVerification(config) {
+  const { apiUrl, polling, qr, fetch: fetchFn } = config;
+  const client = createApiClient({ baseUrl: apiUrl, fetch: fetchFn });
+  const subscribers = /* @__PURE__ */ new Set();
+  let currentState = { status: "idle" };
+  let currentSessionId = null;
+  let poller = null;
+  function setState(newState) {
+    currentState = newState;
+    for (const callback of subscribers) {
+      try {
+        callback(newState);
+      } catch {
+      }
+    }
+  }
+  function mapSessionToState(session) {
+    switch (session.status) {
+      case "pending":
+        if (session.qrUrl) {
+          return {
+            status: "showQR",
+            qrDataUrl: generateQRDataUrl(session.qrUrl, qr),
+            qrUrl: session.qrUrl,
+            sessionId: session.id
+          };
+        }
+        return { status: "loading" };
+      case "waiting_for_wallet":
+        return { status: "waitingForWallet", sessionId: session.id };
+      case "verified":
+        return {
+          status: "verified",
+          token: session.token,
+          claims: session.claims
+        };
+      case "rejected":
+        return { status: "rejected", error: session.error };
+      case "expired":
+        return { status: "expired" };
+      case "cancelled":
+        return { status: "idle" };
+      case "error":
+        return { status: "error", error: session.error ?? "Verification failed" };
+      default:
+        return { status: "error", error: "Unknown session status" };
+    }
+  }
+  async function pollSession() {
+    if (!currentSessionId) return true;
+    try {
+      const session = await client.getSession(currentSessionId);
+      const newState = mapSessionToState(session);
+      if (newState.status !== currentState.status || newState.status === "showQR" && currentState.status === "showQR" && newState.sessionId !== currentState.sessionId) {
+        setState(newState);
+      }
+      if (isTerminalStatus(session.status)) {
+        return true;
+      }
+      return false;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      setState({ status: "error", error: errorMessage });
+      return true;
+    }
+  }
+  function stopPolling() {
+    if (poller) {
+      poller.stop();
+      poller = null;
+    }
+  }
+  function startPolling() {
+    stopPolling();
+    poller = createPoller(pollSession, polling);
+    poller.start();
+  }
+  return {
+    get state() {
+      return currentState;
+    },
+    async start(request) {
+      stopPolling();
+      currentSessionId = null;
+      setState({ status: "loading" });
+      try {
+        const session = await client.createSession(request);
+        currentSessionId = session.id;
+        const newState = mapSessionToState(session);
+        setState(newState);
+        if (!isTerminalStatus(session.status)) {
+          startPolling();
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        setState({ status: "error", error: errorMessage });
+      }
+    },
+    async cancel() {
+      if (!currentSessionId) return;
+      stopPolling();
+      try {
+        await client.cancelSession(currentSessionId);
+        currentSessionId = null;
+        setState({ status: "idle" });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Failed to cancel";
+        setState({ status: "error", error: errorMessage });
+      }
+    },
+    destroy() {
+      stopPolling();
+      currentSessionId = null;
+      subscribers.clear();
+    },
+    subscribe(callback) {
+      subscribers.add(callback);
+      try {
+        callback(currentState);
+      } catch {
+      }
+      return () => {
+        subscribers.delete(callback);
+      };
+    }
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  ApiResponseError,
+  EudiClientError,
+  NetworkError,
+  RateLimitError,
+  SessionExpiredError,
+  SessionNotFoundError,
+  TERMINAL_STATUSES,
+  VERSION,
+  VerificationCancelledError,
+  createApiClient,
+  createPoller,
+  createVerification,
+  generateQRDataUrl,
+  generateQRSvg,
+  isTerminalStatus
+};