@gerege-systems/eid-mongolia-sdk 0.12.1 → 0.14.0

package/dist/index.js

@@ -167,13 +167,6 @@ function routePath(route, ...args) {
   if (i !== args.length) throw new Error(`eid: route ${route.path}: \u043F\u0430\u0440\u0430\u043C\u0435\u0442\u0440 \u0438\u043B\u04AF\u04AF`);
   return out;
 }
-var OIDC_EXPECT = {
-  defaultScope: "openid",
-  pkceMethod: "S256",
-  idTokenAlg: "ES256",
-  /** `Authorization: Basic` (RFC 6749 §2.3.1). */
-  tokenEndpointAuthMethod: "client_secret_basic"
-};
 
 // src/crypto.ts
 import { createHash, randomBytes } from "crypto";
@@ -1590,6 +1583,8 @@ var EidClient = class {
   token;
   session;
   validator;
+  /** `credentials.rpName` — иргэний утсанд харагдах RP нэр. */
+  rpName;
   constructor(cfg) {
     if (!cfg.credentials?.apiSecret) throw new Error("EidClient: credentials.apiSecret \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
     const base = resolveBaseUrl(cfg.baseUrl);
@@ -1614,6 +1609,7 @@ var EidClient = class {
     this.token = new TokenApi(http, cfg.credentials);
     this.session = new SessionApi(http);
     this.validator = new ResponseValidator(cfg.trust ?? {});
+    this.rpName = cfg.credentials.rpName;
   }
 };
 
@@ -1687,281 +1683,371 @@ function qrDeviceLinkTicker(input, onLink, opts) {
   return () => clearInterval(t);
 }
 
-// src/oidc.ts
-import { timingSafeEqual as timingSafeEqual2 } from "crypto";
-var EID_OIDC_ISSUER = "https://login.eidmongolia.mn";
-var EID_ACR_QUALIFIED = "urn:eidmongolia:loa:qualified";
-var EID_ACR_ADVANCED = "urn:eidmongolia:loa:advanced";
-var CLOCK_SKEW_S = 60;
-var CACHE_MS = 60 * 60 * 1e3;
-var DEFAULT_TIMEOUT_MS2 = 1e4;
-var KNOWN_CODES = /* @__PURE__ */ new Set([
-  "access_denied",
-  "login_required",
-  "invalid_request",
-  "invalid_scope",
-  "unauthorized_client",
-  "unsupported_response_type",
-  "request_not_supported",
-  "temporarily_unavailable",
-  "server_error",
-  "invalid_client",
-  "invalid_grant",
-  "unsupported_grant_type"
-]);
-var EidOidcError = class extends EidError {
-  constructor(code, message, description) {
-    super(message);
-    this.code = code;
-    this.description = description;
-  }
-  code;
-  description;
-};
-var EidOidcClient = class {
-  constructor(cfg) {
-    this.cfg = cfg;
-    if (!cfg.clientId) throw new EidError("EidOidcClient: clientId \u0445\u043E\u043E\u0441\u043E\u043D");
-    if (!cfg.clientSecret) throw new EidError("EidOidcClient: clientSecret \u0445\u043E\u043E\u0441\u043E\u043D");
-    if (!/^https:\/\//.test(cfg.redirectUri ?? "")) throw new EidError("EidOidcClient: redirectUri https:// \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439");
-    this.issuer = (cfg.issuer ?? EID_OIDC_ISSUER).replace(/\/+$/, "");
-    this.scope = cfg.scope ?? OIDC_EXPECT.defaultScope;
-  }
-  cfg;
-  issuer;
-  scope;
-  discovery;
-  jwks;
-  /** Discovery document (1 цаг cache). `issuer` нь тохиргоотой яг таарах ёстой (OIDC Discovery §4.3). */
-  discover() {
-    const c = this.discovery;
-    if (c && Date.now() - c.at < CACHE_MS) return c.d;
-    const d = this.fetchDiscovery();
-    this.discovery = { at: Date.now(), d };
-    d.catch(() => {
-      if (this.discovery?.d === d) this.discovery = void 0;
-    });
-    return d;
-  }
-  async fetchDiscovery() {
-    const d = await this.getJson(this.issuer + "/.well-known/openid-configuration");
-    if (!d || d.issuer !== this.issuer) {
-      throw new EidOidcError("discovery_failed", `OIDC discovery-\u0438\u0439\u043D issuer \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439 (\u0445\u04AF\u043B\u044D\u044D\u0441\u044D\u043D ${this.issuer})`);
-    }
-    for (const k of ["authorization_endpoint", "token_endpoint", "jwks_uri"]) {
-      if (typeof d[k] !== "string" || !d[k].startsWith("https://")) {
-        throw new EidOidcError("discovery_failed", `OIDC discovery: ${k} \u0431\u0443\u0440\u0443\u0443`);
+// src/login.ts
+import { createHash as createHash5, randomBytes as randomBytes2, timingSafeEqual as timingSafeEqual2 } from "crypto";
+function memoryLoginStore() {
+  const m = /* @__PURE__ */ new Map();
+  return {
+    get(k) {
+      const e = m.get(k);
+      if (!e) return void 0;
+      if (e.exp <= Date.now()) {
+        m.delete(k);
+        return void 0;
+      }
+      return e.tx;
+    },
+    set(k, tx, ttl) {
+      const now = Date.now();
+      if (m.size > 1e3) {
+        for (const [key, e] of m) if (e.exp <= now) m.delete(key);
       }
+      m.set(k, { tx, exp: now + ttl });
+    },
+    delete(k) {
+      return m.delete(k);
+    }
+  };
+}
+var CALLBACK_PATH = "/auth/eid/callback";
+var ID_RE = /^(\p{L}{2}[0-9]{8}|[0-9]{8,14}|PNOMN-[0-9]{8,14})$/u;
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var B64URL_RE = /^[A-Za-z0-9_-]{43}$/;
+var IOS_BROWSERS = [
+  [/CriOS/i, "googlechromes"],
+  [/EdgiOS/i, "microsoft-edge-https"],
+  [/FxiOS/i, "firefox"],
+  [/OPT\//i, "touch-https"],
+  [/OPiOS|OPR\//i, "opera-https"],
+  [/DuckDuckGo/i, "ddgQuickLink"]
+];
+var ANDROID_BROWSERS = [
+  [/EdgA\//i, "com.microsoft.emmx"],
+  [/Opera Mini/i, "com.opera.mini.native"],
+  [/OPR\//i, "com.opera.browser"],
+  [/SamsungBrowser\//i, "com.sec.android.app.sbrowser"],
+  [/YaBrowser\//i, "com.yandex.browser"],
+  [/DuckDuckGo\//i, "com.duckduckgo.mobile.android"],
+  [/Vivaldi\//i, "com.vivaldi.browser"],
+  [/Firefox\//i, "org.mozilla.firefox"],
+  [/Chrome\//i, "com.android.chrome"]
+];
+function withReturnHint(callbackUrl, userAgent) {
+  const u = new URL(callbackUrl);
+  const pick = (t) => t.find(([re]) => re.test(userAgent))?.[1];
+  if (/iPhone|iPad|iPod/i.test(userAgent)) {
+    const v = pick(IOS_BROWSERS);
+    if (v) u.searchParams.set("retScheme", v);
+  } else if (/Android/i.test(userAgent)) {
+    const v = pick(ANDROID_BROWSERS);
+    if (v) u.searchParams.set("retPkg", v);
+  }
+  return u.toString();
+}
+function header(h, name) {
+  const v = h[name] ?? h[name.toLowerCase()];
+  return (Array.isArray(v) ? v[0] : v) ?? "";
+}
+function readCookie(h, name) {
+  for (const part of header(h, "cookie").split(";")) {
+    const i = part.indexOf("=");
+    if (i > 0 && part.slice(0, i).trim() === name) return part.slice(i + 1).trim();
+  }
+  return "";
+}
+var sha256hex = (s) => createHash5("sha256").update(s).digest("hex");
+function safeEqualHex(a, b) {
+  const x = Buffer.from(a, "hex");
+  const y = Buffer.from(b, "hex");
+  return x.length === y.length && x.length > 0 && timingSafeEqual2(x, y);
+}
+function toIdentity(r, v, flowType) {
+  const s = v.parsedSubject;
+  const etsi = s.serialNumber ?? "";
+  const m = /^PNOMN-([0-9]+)$/.exec(etsi);
+  return {
+    etsi,
+    civilId: m ? m[1] : null,
+    givenName: s.givenName ?? null,
+    surname: s.surname ?? null,
+    name: s.name,
+    country: s.country ?? null,
+    documentNumber: v.documentNumber,
+    certificateLevel: v.certificateLevel,
+    certificateDerB64: r.certificateDerB64 ?? "",
+    flowType,
+    person: personMatchesCertificate(r.person, s) ? r.person ?? null : null
+  };
+}
+function createEidLogin(opts) {
+  const client = opts.client;
+  if (!opts.onSuccess) throw new Error("createEidLogin: onSuccess \u0448\u0430\u0430\u0440\u0434\u043B\u0430\u0433\u0430\u0442\u0430\u0439");
+  if (opts.callbackUrl) {
+    const u = new URL(opts.callbackUrl);
+    if (u.protocol !== "https:" || u.pathname !== CALLBACK_PATH) {
+      throw new Error(`createEidLogin: callbackUrl \u043D\u044C https://<\u0442\u0430\u043D\u044B host>${CALLBACK_PATH} \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439`);
     }
-    return d;
   }
-  /**
-   * Authorize URL + санамсаргүй state / nonce / PKCE codeVerifier. RP буцаасан `state`, `nonce`, `codeVerifier`-ийг
-   * хөтчийн session-тэй холбож (httpOnly cookie эсвэл server session) хадгалаад хөтчийг `url` руу 302 хийнэ.
-   */
-  async createAuthorization(opts = {}) {
-    const d = await this.discover();
-    const state = randomB64url(32);
-    const nonce = randomB64url(32);
-    const codeVerifier = randomB64url(32);
-    const u = new URL(d.authorization_endpoint);
-    const p = new URLSearchParams({
-      response_type: "code",
-      client_id: this.cfg.clientId,
-      redirect_uri: this.cfg.redirectUri,
-      scope: opts.scope ?? this.scope,
-      state,
-      nonce,
-      code_challenge: await pkceChallenge(codeVerifier),
-      code_challenge_method: OIDC_EXPECT.pkceMethod
+  const store = opts.store ?? memoryLoginStore();
+  const ttl = opts.ttlMs ?? 12e4;
+  const pollMs = opts.pollMs ?? 1e3;
+  const cookieName = opts.cookie?.name ?? "eid_login";
+  const cookiePath = opts.cookie?.path ?? "/";
+  const secure = opts.cookie?.secure ?? true;
+  const successRedirect = opts.successRedirect ?? "/";
+  const failureRedirect = opts.failureRedirect ?? "/";
+  const onError = opts.onError ?? ((e) => console.error("eid-login:", e instanceof Error ? e.message : e));
+  const pushHits = /* @__PURE__ */ new Map();
+  const rateLimit = opts.rateLimit ?? ((key) => {
+    if (!key.startsWith("push:")) return true;
+    const now = Date.now();
+    const hits = (pushHits.get(key) ?? []).filter((t) => now - t < 6e4);
+    if (pushHits.size > 1e4) pushHits.clear();
+    if (hits.length >= 3) return false;
+    hits.push(now);
+    pushHits.set(key, hits);
+    return true;
+  });
+  const displayText = (opts.displayText ?? `${client.rpName}-\u0434 \u043D\u044D\u0432\u0442\u0440\u044D\u0445`).slice(0, 60);
+  const interactions = [{ type: "displayTextAndPIN", displayText60: displayText }];
+  const json = (status2, body, extra = {}) => ({
+    status: status2,
+    headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store", ...extra },
+    body: JSON.stringify(body)
+  });
+  const cookieAttrs = (maxAge) => `Path=${cookiePath}; Max-Age=${maxAge}; HttpOnly; SameSite=Lax${secure ? "; Secure" : ""}` + (opts.cookie?.domain ? `; Domain=${opts.cookie.domain}` : "");
+  const clearCookie = `${cookieName}=; ${cookieAttrs(0)}`;
+  const redirect = (to, extra = {}) => ({
+    status: 303,
+    headers: { Location: to, "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", ...extra },
+    body: ""
+  });
+  const failTo = (code) => {
+    const u = new URL(failureRedirect, "http://x");
+    u.searchParams.set("eid_error", code);
+    return /^https?:/i.test(failureRedirect) ? u.toString() : u.pathname + u.search + u.hash;
+  };
+  const mergeHeaders = (a, b) => {
+    const out = { ...a };
+    for (const [k, v] of Object.entries(b ?? {})) {
+      const key = Object.keys(out).find((x) => x.toLowerCase() === k.toLowerCase()) ?? k;
+      const prev = out[key];
+      out[key] = key.toLowerCase() === "set-cookie" && prev ? [...[prev].flat(), ...[v].flat()] : v;
+    }
+    return out;
+  };
+  async function loadTx(req) {
+    const raw = readCookie(req.headers, cookieName);
+    const dot = raw.indexOf(".");
+    const sid = raw.slice(0, dot);
+    const binding = raw.slice(dot + 1);
+    if (dot < 0 || !UUID_RE.test(sid) || !B64URL_RE.test(binding)) return void 0;
+    const tx = await store.get(sid);
+    if (!tx || !safeEqualHex(tx.bindingHash, sha256hex(binding))) return void 0;
+    if (tx.expiresAt <= Date.now()) {
+      await store.delete(sid);
+      return void 0;
+    }
+    return tx;
+  }
+  function qrLink(tx) {
+    if (tx.mode !== "qr" || !tx.link) return void 0;
+    return buildDeviceLink({
+      deviceLinkBase: tx.link.base,
+      deviceLinkType: "QR",
+      sessionToken: tx.link.token,
+      sessionSecret: tx.link.secret,
+      sessionType: "auth",
+      lang: tx.link.lang,
+      receivedAt: tx.link.receivedAt,
+      rpChallenge: tx.acsp.rpChallenge,
+      relyingPartyName: tx.acsp.relyingPartyName,
+      interactions: tx.acsp.interactions
     });
-    if (opts.display) p.set("display", opts.display);
-    u.search = p.toString();
-    return { url: u.toString(), state, nonce, codeVerifier };
   }
-  /**
-   * redirect_uri руу ирсэн callback-ийг шийднэ: state тулгах → `error` бол {@link EidOidcError} → code солих →
-   * id_token шалгах. `input` — бүтэн callback URL, харьцангуй зам (`/cb?code=…`) эсвэл query (`URLSearchParams` / `code=…&state=…`); зөвхөн query-г уншина.
-   * Амжилтгүй бүх тохиолдолд {@link EidOidcError} (эсвэл {@link NetworkError}) шиднэ.
-   */
-  async handleCallback(input, checks) {
-    const q = callbackParams(input);
-    const state = q.get("state") ?? "";
-    if (!checks.state || !timingSafeEqualStr(state, checks.state)) {
-      throw new EidOidcError("state_mismatch", "OIDC state \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439 \u2014 \u043D\u044D\u0432\u0442\u0440\u044D\u043B\u0442\u0438\u0439\u0433 \u0434\u0430\u0445\u0438\u043D \u044D\u0445\u043B\u04AF\u04AF\u043B\u043D\u044D \u04AF\u04AF");
+  async function begin(req, mode, idCode, lang) {
+    const level = opts.certificateLevel ? { certificateLevel: opts.certificateLevel } : {};
+    let tx;
+    let appLink;
+    if (mode === "push") {
+      const s = await client.auth.notificationByEtsi(idCode, interactions, level);
+      tx = { sessionId: s.sessionId, mode, vc: s.vc, acsp: s.acsp };
+    } else {
+      const callbackUrl = mode === "web2app" ? withReturnHint(opts.callbackUrl, header(req.headers, "user-agent")) : void 0;
+      const s = await client.auth.deviceLinkAnonymous(interactions, { ...level, callbackUrl });
+      if (!s.deviceLinkBase || !s.sessionToken || !s.sessionSecret || !s.acsp) throw new Error("eID \u0445\u0430\u0440\u0438\u0443\u043D\u0434 device link \u0442\u0430\u043B\u0431\u0430\u0440 \u0434\u0443\u0442\u0443\u0443");
+      tx = {
+        sessionId: s.sessionId,
+        mode,
+        vc: s.vc,
+        acsp: s.acsp,
+        link: { base: s.deviceLinkBase, token: s.sessionToken, secret: s.sessionSecret, receivedAt: s.receivedAt, lang }
+      };
+      if (mode === "web2app") {
+        appLink = buildDeviceLink({
+          deviceLinkBase: s.deviceLinkBase,
+          deviceLinkType: "Web2App",
+          sessionToken: s.sessionToken,
+          sessionSecret: s.sessionSecret,
+          sessionType: "auth",
+          lang,
+          rpChallenge: s.acsp.rpChallenge,
+          relyingPartyName: s.acsp.relyingPartyName,
+          interactions: s.acsp.interactions,
+          initialCallbackUrl: s.acsp.initialCallbackUrl
+        });
+      }
+    }
+    const binding = randomBytes2(32).toString("base64url");
+    const full = { ...tx, bindingHash: sha256hex(binding), expiresAt: Date.now() + ttl };
+    await store.set(full.sessionId, full, ttl);
+    const setCookie = `${cookieName}=${full.sessionId}.${binding}; ${cookieAttrs(Math.ceil(ttl / 1e3))}`;
+    return { tx: full, setCookie, appLink };
+  }
+  async function start(req) {
+    const url = new URL(req.url, "http://x");
+    const site = header(req.headers, "sec-fetch-site");
+    if (site && site !== "same-origin" && site !== "same-site" && site !== "none") return json(403, { error: "cross_site" });
+    let body = {};
+    if (req.method === "GET") {
+      if (url.searchParams.get("mode") !== "web2app") return json(405, { error: "method_not_allowed" });
+      body = { mode: "web2app", lang: url.searchParams.get("lang") ?? void 0 };
+    } else if (req.method === "POST") {
+      if (!header(req.headers, "content-type").toLowerCase().startsWith("application/json")) {
+        return json(415, { error: "json_required" });
+      }
+      try {
+        const b = typeof req.body === "string" ? JSON.parse(req.body) : req.body;
+        if (b && typeof b === "object") body = b;
+      } catch {
+        return json(400, { error: "invalid_body" });
+      }
+    } else {
+      return json(405, { error: "method_not_allowed" });
     }
-    const iss = q.get("iss");
-    if (iss !== null && iss !== this.issuer) {
-      throw new EidOidcError("invalid_callback", "OIDC callback-\u0438\u0439\u043D iss \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
+    const mode = body.mode;
+    if (mode !== "qr" && mode !== "push" && mode !== "web2app") return json(400, { error: "invalid_mode" });
+    const lang = body.lang === "en" ? "eng" : "mon";
+    const ctx = { request: req, mode };
+    if (mode === "web2app" && !opts.callbackUrl) return json(400, { error: "web2app_not_configured" });
+    const idCode = typeof body.idCode === "string" ? body.idCode.replace(/\s+/g, "").toUpperCase() : "";
+    if (mode === "push" && !ID_RE.test(idCode)) return json(400, { error: "invalid_id" });
+    const limited = () => json(429, { error: "rate_limited" }, { "Retry-After": "60" });
+    if (req.ip && !await rateLimit(`start:${req.ip}`)) return limited();
+    if (mode === "push" && !await rateLimit(`push:${idCode}`)) return limited();
+    let r;
+    try {
+      r = await begin(req, mode, idCode, lang);
+    } catch (e) {
+      onError(e, ctx);
+      const status2 = e instanceof ApiError && e.status === 429 ? 429 : 502;
+      return json(status2, { error: status2 === 429 ? "rate_limited" : "eid_unavailable" });
     }
-    const err = q.get("error");
-    if (err) {
-      const code2 = KNOWN_CODES.has(err) ? err : "server_error";
-      throw new EidOidcError(code2, `eID \u043D\u044D\u0432\u0442\u0440\u044D\u043B\u0442 \u0430\u043C\u0436\u0438\u043B\u0442\u0433\u04AF\u0439: ${code2}`, q.get("error_description") ?? void 0);
+    if (mode === "web2app") {
+      return { status: 302, headers: { Location: r.appLink, "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", "Set-Cookie": r.setCookie }, body: "" };
     }
-    const code = q.get("code") ?? "";
-    if (code === "" || code.length > 512) throw new EidOidcError("invalid_callback", "OIDC callback-\u0434 code \u0430\u043B\u0433\u0430");
-    const idToken = await this.exchangeCode(code, checks.codeVerifier);
-    const claims = await this.verifyIdToken(idToken, { nonce: checks.nonce });
-    return { claims, idToken };
-  }
-  /** `POST token_endpoint` (client_secret_basic, RFC 6749 §2.3.1) → id_token. */
-  async exchangeCode(code, codeVerifier) {
-    const d = await this.discover();
-    const basic = Buffer.from(formEncode(this.cfg.clientId) + ":" + formEncode(this.cfg.clientSecret)).toString("base64");
-    const res = await this.fetch(d.token_endpoint, {
-      method: "POST",
-      headers: {
-        Authorization: "Basic " + basic,
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json"
-      },
-      body: new URLSearchParams({
-        grant_type: "authorization_code",
-        code,
-        redirect_uri: this.cfg.redirectUri,
-        code_verifier: codeVerifier
-      }).toString()
-    });
-    let j = {};
+    return json(
+      200,
+      { mode, vc: r.tx.vc, ...mode === "qr" ? { qr: qrLink(r.tx) } : {}, expiresIn: Math.ceil(ttl / 1e3) },
+      { "Set-Cookie": r.setCookie }
+    );
+  }
+  async function finish(req, tx, r, flow, verifier) {
+    const v = client.validator.validateAuth(r, tx.acsp, { expectedFlowType: flow, userChallengeVerifier: verifier });
+    if (!await store.delete(tx.sessionId)) return void 0;
+    const out = await opts.onSuccess(toIdentity(r, v, flow), { request: req, mode: tx.mode }) ?? {};
+    return out;
+  }
+  async function status(req) {
+    if (req.method !== "GET") return json(405, { error: "method_not_allowed" });
+    const tx = await loadTx(req);
+    if (!tx) return json(200, { state: "EXPIRED" }, { "Set-Cookie": clearCookie });
+    const ctx = { request: req, mode: tx.mode };
+    let r;
     try {
-      j = await res.json();
-    } catch {
+      r = await client.session.poll(tx.sessionId, pollMs);
+    } catch (e) {
+      if (e instanceof ApiError && e.status === 404) {
+        await store.delete(tx.sessionId);
+        return json(200, { state: "EXPIRED" }, { "Set-Cookie": clearCookie });
+      }
+      onError(e, ctx);
+      return json(502, { error: "eid_unavailable" });
     }
-    if (!res.ok) {
-      const e = typeof j.error === "string" && KNOWN_CODES.has(j.error) ? j.error : "server_error";
-      throw new EidOidcError(
-        e,
-        `OIDC token ${res.status}: ${e}`,
-        typeof j.error_description === "string" ? j.error_description : void 0
-      );
+    const expiresIn = Math.max(0, Math.ceil((tx.expiresAt - Date.now()) / 1e3));
+    if (r.state !== "COMPLETE") return json(200, { state: "PENDING", qr: qrLink(tx), vc: tx.vc, expiresIn });
+    if (r.endResult !== "OK") {
+      await store.delete(tx.sessionId);
+      return json(200, { state: "FAILED", error: r.endResult ?? "UNKNOWN" }, { "Set-Cookie": clearCookie });
     }
-    if (typeof j.id_token !== "string" || j.id_token === "") {
-      throw new EidOidcError("server_error", "OIDC token \u0445\u0430\u0440\u0438\u0443\u043D\u0434 id_token \u0430\u043B\u0433\u0430");
+    if (tx.mode === "web2app") return json(200, { state: "WAIT_CALLBACK" });
+    try {
+      const out = await finish(req, tx, r, tx.mode === "qr" ? "QR" : "Notification");
+      if (!out) return json(200, { state: "EXPIRED" }, { "Set-Cookie": clearCookie });
+      return json(200, { state: "OK", redirect: out.redirect, data: out.data }, mergeHeaders({ "Set-Cookie": clearCookie }, out.headers));
+    } catch (e) {
+      onError(e, ctx);
+      if (!(e instanceof ValidationError || e instanceof SessionFailedError)) return json(500, { error: "internal" });
+      await store.delete(tx.sessionId);
+      return json(200, { state: "FAILED", error: "VALIDATION" }, { "Set-Cookie": clearCookie });
     }
-    return j.id_token;
   }
-  /**
-   * id_token шалгана: JWKS (`kid`, cache; танихгүй kid → нэг удаа дахин татна) ES256 гарын үсэг, `iss`, `aud`
-   * (= clientId; олон aud бол `azp`), `exp`/`iat` (±60 сек), `nonce`. Амжилтгүй бол `invalid_id_token`.
-   */
-  async verifyIdToken(idToken, opts) {
-    const bad = (why) => new EidOidcError("invalid_id_token", `id_token: ${why}`);
-    const parts = idToken.split(".");
-    if (parts.length !== 3) throw bad("\u0445\u044D\u043B\u0431\u044D\u0440 \u0431\u0443\u0440\u0443\u0443");
-    const header = decodeJsonPart(parts[0]);
-    const payload = decodeJsonPart(parts[1]);
-    if (!header || !payload) throw bad("\u0445\u044D\u043B\u0431\u044D\u0440 \u0431\u0443\u0440\u0443\u0443");
-    if (header.alg !== OIDC_EXPECT.idTokenAlg) throw bad("alg ES256 \u0431\u0438\u0448");
-    const kid = typeof header.kid === "string" ? header.kid : "";
-    if (!kid) throw bad("kid \u0430\u043B\u0433\u0430");
-    const pick = (ks) => ks.find(
-      (k) => k.kid === kid && k.kty === "EC" && k.crv === "P-256" && (k.use === void 0 || k.use === "sig") && (k.alg === void 0 || k.alg === "ES256")
-    );
-    const jwk = pick(await this.keys(false)) ?? pick(await this.keys(true));
-    if (!jwk || !jwk.x || !jwk.y) throw bad(`\u0442\u0430\u043D\u0438\u0445\u0433\u04AF\u0439 kid ${kid}`);
-    const sig = Buffer.from(parts[2], "base64url");
-    if (sig.length !== 64) throw bad("\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
-    let ok = false;
+  async function callback(req) {
+    if (req.method !== "GET") return json(405, { error: "method_not_allowed" });
+    const q = new URL(req.url, "http://x").searchParams;
+    const sid = q.get("sessionId") ?? "";
+    const verifier = q.get("userChallengeVerifier") ?? "";
+    const fail2 = (code) => redirect(failTo(code), { "Set-Cookie": clearCookie });
+    const tx = await loadTx(req);
+    if (!tx || tx.sessionId !== sid || tx.mode !== "web2app") return fail2(tx ? "unbound" : "expired");
+    if (!verifier) return fail2("unbound");
+    const ctx = { request: req, mode: tx.mode };
+    let r;
     try {
-      const key = await globalThis.crypto.subtle.importKey(
-        "jwk",
-        { kty: "EC", crv: "P-256", x: jwk.x, y: jwk.y },
-        { name: "ECDSA", namedCurve: "P-256" },
-        false,
-        ["verify"]
-      );
-      ok = await globalThis.crypto.subtle.verify(
-        { name: "ECDSA", hash: "SHA-256" },
-        key,
-        sig,
-        new TextEncoder().encode(parts[0] + "." + parts[1])
-      );
-    } catch {
-      ok = false;
+      r = await client.session.poll(tx.sessionId, 1e4);
+    } catch (e) {
+      onError(e, ctx);
+      return fail2("eid_unavailable");
+    }
+    if (r.state !== "COMPLETE") return fail2("not_complete");
+    if (r.endResult !== "OK") {
+      await store.delete(tx.sessionId);
+      return fail2(r.endResult ?? "UNKNOWN");
     }
-    if (!ok) throw bad("\u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
-    const c = payload;
-    const now = Math.floor(Date.now() / 1e3);
-    if (c.iss !== this.issuer) throw bad("iss \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
-    const aud = Array.isArray(c.aud) ? c.aud : [c.aud];
-    if (!aud.includes(this.cfg.clientId)) throw bad("aud \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
-    if (aud.length > 1 && c.azp !== this.cfg.clientId) throw bad("azp \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
-    if (typeof c.exp !== "number" || now > c.exp + CLOCK_SKEW_S) throw bad("\u0445\u0443\u0433\u0430\u0446\u0430\u0430 \u0434\u0443\u0443\u0441\u0441\u0430\u043D");
-    if (typeof c.iat !== "number" || c.iat > now + CLOCK_SKEW_S) throw bad("iat \u0438\u0440\u044D\u044D\u0434\u04AF\u0439\u0434");
-    if (typeof c.nonce !== "string" || !opts.nonce || !timingSafeEqualStr(c.nonce, opts.nonce)) throw bad("nonce \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
-    if (typeof c.sub !== "string" || c.sub === "") throw bad("sub \u0430\u043B\u0433\u0430");
-    return c;
-  }
-  keys(force) {
-    const c = this.jwks;
-    if (!force && c && Date.now() - c.at < CACHE_MS) return c.keys;
-    const keys = this.discover().then(async (d) => {
-      const j = await this.getJson(d.jwks_uri);
-      return Array.isArray(j?.keys) ? j.keys : [];
-    });
-    this.jwks = { at: Date.now(), keys };
-    keys.catch(() => {
-      if (this.jwks?.keys === keys) this.jwks = void 0;
-    });
-    return keys;
-  }
-  async getJson(url) {
-    const res = await this.fetch(url, { method: "GET", headers: { Accept: "application/json" } });
-    if (!res.ok) throw new EidOidcError("discovery_failed", `OIDC ${res.status}: ${url}`);
     try {
-      return await res.json();
-    } catch {
-      throw new EidOidcError("discovery_failed", `OIDC JSON \u0431\u0438\u0448: ${url}`);
+      const out = await finish(req, tx, r, "Web2App", verifier);
+      if (!out) return fail2("expired");
+      return redirect(out.redirect ?? successRedirect, mergeHeaders({ "Set-Cookie": clearCookie }, out.headers));
+    } catch (e) {
+      onError(e, ctx);
+      if (!(e instanceof ValidationError || e instanceof SessionFailedError)) return fail2("internal");
+      await store.delete(tx.sessionId);
+      return fail2("VALIDATION");
     }
   }
-  async fetch(url, init) {
-    const f = this.cfg.fetchImpl ?? fetch;
+  async function handleRequest(req) {
+    const seg = new URL(req.url, "http://x").pathname.replace(/\/+$/, "").split("/").pop();
     try {
-      return await f(url, {
-        ...init,
-        redirect: "error",
-        signal: AbortSignal.timeout(this.cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
-      });
+      if (seg === "start") return await start(req);
+      if (seg === "status") return await status(req);
+      if (seg === "callback") return await callback(req);
     } catch (e) {
-      const err = e;
-      if (err.name === "TimeoutError" || err.name === "AbortError") {
-        throw new NetworkError(`OIDC \u0445\u04AF\u0441\u044D\u043B\u0442 \u0445\u0443\u0433\u0430\u0446\u0430\u0430 \u0445\u044D\u0442\u044D\u0440\u043B\u044D\u044D: ${url}`);
-      }
-      throw new NetworkError(`OIDC \u0441\u04AF\u043B\u0436\u044D\u044D\u043D\u0438\u0439 \u0430\u043B\u0434\u0430\u0430 (${url}): ${err.message}`);
+      onError(e, { request: req, mode: "qr" });
+      if (e instanceof AuthenticationError || e instanceof ForbiddenError) return json(502, { error: "eid_unavailable" });
+      return json(500, { error: "internal" });
     }
+    return json(404, { error: "not_found" });
   }
-};
-async function pkceChallenge(codeVerifier) {
-  const h = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier));
-  return Buffer.from(h).toString("base64url");
-}
-function randomB64url(bytes) {
-  return Buffer.from(globalThis.crypto.getRandomValues(new Uint8Array(bytes))).toString("base64url");
-}
-function formEncode(s) {
-  return new URLSearchParams({ v: s }).toString().slice(2);
-}
-function timingSafeEqualStr(a, b) {
-  const x = Buffer.from(a, "utf8");
-  const y = Buffer.from(b, "utf8");
-  return x.length === y.length && timingSafeEqual2(x, y);
-}
-function decodeJsonPart(s) {
-  try {
-    const v = JSON.parse(Buffer.from(s, "base64url").toString("utf8"));
-    return v && typeof v === "object" && !Array.isArray(v) ? v : null;
-  } catch {
-    return null;
+  async function handle(req) {
+    const headers = {};
+    req.headers.forEach((v, k) => headers[k] = v);
+    const body = req.method === "POST" ? await req.text() : void 0;
+    const r = await handleRequest({ method: req.method, url: req.url, headers, body });
+    const h = new Headers();
+    for (const [k, v] of Object.entries(r.headers)) for (const x of [v].flat()) h.append(k, x);
+    return new Response(r.status === 302 || r.status === 303 || r.body === "" ? null : r.body, { status: r.status, headers: h });
   }
-}
-function callbackParams(input) {
-  if (input instanceof URLSearchParams) return input;
-  if (input instanceof URL) return input.searchParams;
-  const s = input.trim();
-  if (/^https?:\/\//i.test(s)) return new URL(s).searchParams;
-  const i = s.indexOf("?");
-  return new URLSearchParams(i >= 0 ? s.slice(i + 1) : s);
+  return { handleRequest, handle };
 }
 export {
   ApiError,
@@ -1972,13 +2058,8 @@ export {
   DEFAULT_PDF_MAX_BYTES,
   DEFAULT_PDF_TIMEOUT_MS,
   DeviceLinkError,
-  EID_ACR_ADVANCED,
-  EID_ACR_QUALIFIED,
-  EID_OIDC_ISSUER,
   EidClient,
   EidError,
-  EidOidcClient,
-  EidOidcError,
   ForbiddenError,
   Http,
   NetworkError,
@@ -1997,15 +2078,16 @@ export {
   acspV2Digest,
   buildAcspV2Payload,
   buildDeviceLink,
+  createEidLogin,
   deviceLink,
   interactionsToBase64,
   isMobileUserAgent,
+  memoryLoginStore,
   openOrShowQR,
   parseRetryAfter,
   parseSessionResult,
   parseSubject,
   personMatchesCertificate,
-  pkceChallenge,
   qrDeviceLinkTicker,
   randomChallenge,
   resolveBaseUrl,
@@ -2015,5 +2097,6 @@ export {
   userChallengeOf,
   verifyPayloadSignature,
   verifyPrehashedSignature,
-  verifyTokenCertificates
+  verifyTokenCertificates,
+  withReturnHint
 };