@gerege-systems/eid-mongolia-sdk 0.13.0 → 0.14.1

package/dist/index.js

@@ -138,6 +138,11 @@ var RP_ROUTES = {
   authDeviceLinkEtsi: { method: "POST", path: "/authentication/device-link/etsi/{semanticsIdentifier}" },
   signNotificationEtsi: { method: "POST", path: "/signature/notification/etsi/{semanticsIdentifier}" },
   signNotificationDocument: { method: "POST", path: "/signature/notification/document/{documentNumber}" },
+  signNotificationLinked: { method: "POST", path: "/signature/notification/linked/{documentNumber}" },
+  signDeviceLinkEtsi: { method: "POST", path: "/signature/device-link/etsi/{semanticsIdentifier}" },
+  signDeviceLinkDocument: { method: "POST", path: "/signature/device-link/document/{documentNumber}" },
+  certChoiceDeviceLink: { method: "POST", path: "/signature/certificate-choice/device-link/anonymous" },
+  certChoiceEtsi: { method: "POST", path: "/signature/certificate-choice/notification/etsi/{semanticsIdentifier}" },
   pdfPrepare: { method: "POST", path: "/pdf/sign/prepare" },
   pdfDocument: { method: "GET", path: "/pdf/sign/{sessionID}/document" },
   orgRepresentations: { method: "GET", path: "/organization/representations/etsi/{personEtsi}" },
@@ -167,13 +172,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";
@@ -271,7 +269,8 @@ var AuthApi = class {
       vc: vc != null ? String(vc) : null,
       rpChallenge: acsp.rpChallenge,
       acsp,
-      receivedAt: Date.now()
+      receivedAt: Date.now(),
+      sessionType: "auth"
     };
   }
   /** Push — РД/иргэний дугаар/ETSI-ээр (сервер төрлийг таьна). Иргэний утас руу мэдэгдэл очно. */
@@ -300,10 +299,20 @@ var AuthApi = class {
   }
 };
 
+// src/types.ts
+var DEFAULT_SIGN_SESSION_TTL_MS = 6e5;
+function sessionExpiry(sentAtMs, ttlMs) {
+  return sentAtMs + (ttlMs && ttlMs > 0 ? ttlMs : DEFAULT_SIGN_SESSION_TTL_MS);
+}
+
 // src/sign.ts
 function rec2(v) {
   return v && typeof v === "object" ? v : {};
 }
+var vcOf = (r) => {
+  const vc = typeof r.vc === "object" && r.vc !== null ? rec2(r.vc).value : r.vc;
+  return vc != null ? String(vc) : null;
+};
 var SignApi = class {
   constructor(http, creds, defaults) {
     this.http = http;
@@ -313,46 +322,155 @@ var SignApi = class {
   http;
   creds;
   defaults;
-  body(digestB64, interactions, opts) {
+  body(digestB64, interactions, opts, defAlg) {
+    const sign = {
+      digest: digestB64,
+      hashAlgorithm: opts?.hashAlgorithm ?? "SHA-256",
+      signatureAlgorithm: opts?.signatureAlgorithm ?? defAlg,
+      relyingPartyName: this.creds.rpName,
+      interactions: interactionsToBase64(interactions),
+      initialCallbackUrl: opts?.callbackUrl?.trim() ?? ""
+    };
     const body = {
       relyingPartyUUID: this.creds.rpUUID,
-      relyingPartyName: this.creds.rpName,
+      relyingPartyName: sign.relyingPartyName,
       certificateLevel: opts?.certificateLevel ?? this.defaults.certificateLevel,
       signatureProtocol: "RAW_DIGEST_SIGNATURE",
       signatureProtocolParameters: {
         digest: digestB64,
-        signatureAlgorithm: opts?.signatureAlgorithm ?? "rsassa-pss",
-        signatureAlgorithmParameters: { hashAlgorithm: opts?.hashAlgorithm ?? "SHA-256" }
+        signatureAlgorithm: sign.signatureAlgorithm,
+        signatureAlgorithmParameters: { hashAlgorithm: sign.hashAlgorithm }
       },
-      interactions: interactionsToBase64(interactions)
+      interactions: sign.interactions
     };
-    if (opts?.callbackUrl?.trim()) body.initialCallbackUrl = opts.callbackUrl.trim();
+    if (sign.initialCallbackUrl) body.initialCallbackUrl = sign.initialCallbackUrl;
     if (opts?.onBehalfOf?.trim()) body.onBehalfOf = opts.onBehalfOf.trim();
     if (opts?.fileName?.trim()) body.fileName = opts.fileName.trim();
-    return body;
+    return { body, sign };
   }
-  parse(raw) {
-    const r = rec2(raw);
-    const vc = rec2(r.vc).value;
-    return { sessionId: String(r.sessionID), vc: vc != null ? String(vc) : null, rpChallenge: "" };
+  async notification(path, body, sign) {
+    const sent = Date.now();
+    const r = rec2(await this.http.post(path, body));
+    return {
+      sessionId: String(r.sessionID),
+      vc: vcOf(r),
+      rpChallenge: "",
+      ...sign ? { sign } : {},
+      expiresAt: sessionExpiry(sent, this.defaults.sessionTtlMs)
+    };
+  }
+  async deviceLink(path, body, extra) {
+    const sent = Date.now();
+    const r = rec2(await this.http.post(path, body));
+    return {
+      sessionId: String(r.sessionID),
+      sessionToken: r.sessionToken != null ? String(r.sessionToken) : null,
+      sessionSecret: r.sessionSecret != null ? String(r.sessionSecret) : null,
+      deviceLinkBase: r.deviceLinkBase != null ? String(r.deviceLinkBase) : null,
+      vc: vcOf(r),
+      rpChallenge: "",
+      receivedAt: Date.now(),
+      ...extra,
+      expiresAt: sessionExpiry(sent, this.defaults.sessionTtlMs)
+    };
   }
   /**
    * Бэлэн digest-ээр push sign (РД/civil_id/ETSI). Баримт (PDF/файл)-ын байтын SHA-256
    * digest-ийг гаднаас бэлдэж өгнө — текст бус бинар баримтад тохиромжтой.
+   *
+   * ⚠️ Олон утастай иргэнд CA etsi-г ЭХНИЙ идэвхтэй төхөөрөмж рүү шийднэ. Гэрчилгээг урьдчилж мэдэх шаардлагатай бол
+   * (PAdES/CMS) {@link certificateChoiceByEtsi} → {@link digestForSigner}.
    */
   async digestByEtsi(id, digestB64, interactions, opts) {
-    const raw = await this.http.post(routePath(RP_ROUTES.signNotificationEtsi, id), this.body(digestB64, interactions, opts));
-    return this.parse(raw);
+    const { body, sign } = this.body(digestB64, interactions, opts, "rsassa-pss");
+    return this.notification(routePath(RP_ROUTES.signNotificationEtsi, id), body, sign);
   }
-  /** Бэлэн digest-ээр push sign — баримтын дугаараар (auth-аас гарсан documentNumber дээр). */
+  /** Бэлэн digest-ээр push sign — баримтын дугаараар (auth / certificate-choice-оос гарсан documentNumber дээр). */
   async digestByDocument(documentNumber, digestB64, interactions, opts) {
-    const raw = await this.http.post(routePath(RP_ROUTES.signNotificationDocument, documentNumber), this.body(digestB64, interactions, opts));
-    return this.parse(raw);
+    const { body, sign } = this.body(digestB64, interactions, opts, "rsassa-pss");
+    return this.notification(routePath(RP_ROUTES.signNotificationDocument, documentNumber), body, sign);
   }
   /** Текстийн SHA-256 digest-ийг дотроо тооцоод push sign (богино текст баримтад тохиромжтой). */
   async textByEtsi(id, text, interactions, opts) {
     return this.digestByEtsi(id, sha256Base64(text), interactions, opts);
   }
+  /**
+   * QR / Web2App / App2App sign — тодорхой иргэн (РД/civil_id/ETSI). Холбоосыг backend-д
+   * `buildDeviceLink(deviceLinkInput(s, type, lang))`-ээр; Web2App/App2App-д `callbackUrl` заавал.
+   * `validateSign`-д `expectedFlowType` = харуулсан холбоосын төрөл.
+   */
+  async deviceLinkByEtsi(id, digestB64, interactions, opts) {
+    const { body, sign } = this.body(digestB64, interactions, opts, "rsassa-pss");
+    return this.deviceLink(routePath(RP_ROUTES.signDeviceLinkEtsi, id), body, { sessionType: "sign", sign });
+  }
+  /** QR / Web2App / App2App sign — баримтын дугаараар (тодорхой төхөөрөмж). */
+  async deviceLinkByDocument(documentNumber, digestB64, interactions, opts) {
+    const { body, sign } = this.body(digestB64, interactions, opts, "rsassa-pss");
+    return this.deviceLink(routePath(RP_ROUTES.signDeviceLinkDocument, documentNumber), body, { sessionType: "sign", sign });
+  }
+  // ── Certificate-choice ──
+  certChoiceBody(opts) {
+    return {
+      relyingPartyUUID: this.creds.rpUUID,
+      relyingPartyName: this.creds.rpName,
+      certificateLevel: opts?.certificateLevel ?? this.defaults.certificateLevel
+    };
+  }
+  /**
+   * Push: иргэний (РД/civil_id/ETSI) утас руу гарын үсгийн гэрчилгээ сонгуулах хүсэлт (PIN-гүй). Үр дүнг
+   * `session.waitForResult` → `validator.validateCertificateChoice`. CERT эрх шаардана.
+   */
+  async certificateChoiceByEtsi(id, opts) {
+    return this.notification(routePath(RP_ROUTES.certChoiceEtsi, id), this.certChoiceBody(opts));
+  }
+  /**
+   * QR: иргэн хэн болохыг урьдчилж мэдэхгүй үед гэрчилгээ сонгуулах. CA-ийн certificate-choice хүсэлт
+   * initialCallbackUrl авдаггүй тул ЗӨВХӨН QR холбоос (`deviceLinkInput(s, "QR", lang)`). CERT эрх.
+   */
+  async certificateChoiceDeviceLink(opts) {
+    return this.deviceLink(routePath(RP_ROUTES.certChoiceDeviceLink), this.certChoiceBody(opts), {
+      sessionType: "cert",
+      relyingPartyName: this.creds.rpName
+    });
+  }
+  // ── Гэрчилгээ урьдчилж мэдэгдэх гарын үсэг (client-side PAdES / CMS) ──
+  signerBody(signer, digestB64, interactions, opts) {
+    if (!signer?.documentNumber?.trim()) {
+      throw new Error("eid: signer.documentNumber \u0445\u043E\u043E\u0441\u043E\u043D \u2014 validateCertificateChoice-\u0438\u0439\u043D \u04AF\u0440 \u0434\u04AF\u043D\u0433 \u04E9\u0433");
+    }
+    const out = this.body(digestB64, interactions, opts, "sha256WithRSAEncryption");
+    const want = hashLen(out.sign.hashAlgorithm);
+    const d = /^[A-Za-z0-9+/]*={0,2}$/.test(digestB64) ? Buffer.from(digestB64, "base64") : null;
+    if (!d || d.length !== want || d.toString("base64") !== digestB64) {
+      throw new Error(`eid: digest \u043D\u044C \u0441\u0442\u0430\u043D\u0434\u0430\u0440\u0442 base64, ${out.sign.hashAlgorithm}-\u0438\u0439\u043D \u0443\u0440\u0442 (${want} \u0431\u0430\u0439\u0442) \u0431\u0430\u0439\u0445 \u0451\u0441\u0442\u043E\u0439`);
+    }
+    return out;
+  }
+  /**
+   * Certificate-choice-оор сонгосон ЯГ ТЭР төхөөрөмж (`signer.documentNumber`) рүү push sign. Олон утастай иргэнд
+   * etsi-ээр эхлүүлбэл өөр утас (өөр гэрчилгээ) зурж, гэрчилгээг урьдчилж оруулсан CMS (PAdES signingCertificateV2)
+   * хүчингүй болдог — тиймээс digest-ийг ҮРГЭЛЖ documentNumber-аар зуруулна.
+   *
+   * `signer.certChoiceSessionId` байвал `/signature/notification/linked/{documentNumber}` (`linkedSessionID`), эс
+   * бөгөөс `/signature/notification/document/{documentNumber}`. Default `sha256WithRSAEncryption` + SHA-256 (digest =
+   * 32 байт DTBS); digest-ийн урт буруу бол хүсэлт явахгүй. Хариуг:
+   * `validator.validateSign(r, s.sign.digest, { hashAlgorithm: s.sign.hashAlgorithm, expectedAlgorithm:
+   * s.sign.signatureAlgorithm, expectedCertificate: signer.certificate, expectedFlowType: "Notification" })`.
+   */
+  async digestForSigner(signer, digestB64, interactions, opts) {
+    const { body, sign } = this.signerBody(signer, digestB64, interactions, opts);
+    const linked = signer.certChoiceSessionId?.trim();
+    if (linked) {
+      body.linkedSessionID = linked;
+      return this.notification(routePath(RP_ROUTES.signNotificationLinked, signer.documentNumber), body, sign);
+    }
+    return this.notification(routePath(RP_ROUTES.signNotificationDocument, signer.documentNumber), body, sign);
+  }
+  /** {@link digestForSigner}-ийн QR / Web2App / App2App хувилбар: `/signature/device-link/document/{documentNumber}`. */
+  async deviceLinkForSigner(signer, digestB64, interactions, opts) {
+    const { body, sign } = this.signerBody(signer, digestB64, interactions, opts);
+    return this.deviceLink(routePath(RP_ROUTES.signDeviceLinkDocument, signer.documentNumber), body, { sessionType: "sign", sign });
+  }
 };
 
 // src/session.ts
@@ -1113,13 +1231,19 @@ var ResponseValidator = class {
    * @param opts — `hashAlgorithm` мөр (хуучин хэлбэр; default SHA-256) эсвэл {@link ValidateSignOptions}.
    */
   validateSign(result, digestB64, opts = {}) {
-    const { hashAlgorithm = "SHA-256", expectedFlowType } = typeof opts === "string" ? { hashAlgorithm: opts } : opts;
+    const o = typeof opts === "string" ? { hashAlgorithm: opts } : opts;
+    const { hashAlgorithm = "SHA-256", expectedFlowType } = o;
     const leaf = this.precheck(result, "RAW_DIGEST_SIGNATURE");
     if (expectedFlowType && result.flowType !== expectedFlowType) {
       throw new ValidationError(`flowType ${result.flowType} \u2260 \u044D\u0445\u043B\u04AF\u04AF\u043B\u0441\u044D\u043D \u0443\u0440\u0441\u0433\u0430\u043B ${expectedFlowType} (relay \u0431\u0430\u0439\u0436 \u0431\u043E\u043B\u0437\u043E\u0448\u0433\u04AF\u0439)`);
     }
+    if (o.expectedCertificate && !leaf.raw.equals(o.expectedCertificate.raw)) {
+      throw new ValidationError(
+        `\u0413\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D certificate-choice-\u043E\u043E\u0440 \u0441\u043E\u043D\u0433\u043E\u0441\u043E\u043D\u0442\u043E\u0439 \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439 (serial ${leaf.serialNumber} \u2260 ${o.expectedCertificate.serialNumber})`
+      );
+    }
     const digest = Buffer.from(digestB64, "base64");
-    const { alg, hash } = this.algorithmOf(result, leaf, null, hashAlgorithm);
+    const { alg, hash } = this.algorithmOf(result, leaf, o.expectedAlgorithm ?? null, hashAlgorithm);
     if (digest.length !== hashLen(hash)) throw new ValidationError("digest \u0443\u0440\u0442 hashAlgorithm-\u0442\u0430\u0439 \u0442\u0430\u0430\u0440\u0430\u0445\u0433\u04AF\u0439");
     if (!verifyPrehashedSignature(digest, result.signatureValueB64, leaf.publicKey, alg, hash)) {
       throw new ValidationError("\u0413\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u04E9\u0433\u0441\u04E9\u043D digest-\u0442\u044D\u0439 \u0442\u0430\u0430\u0440\u0441\u0430\u043D\u0433\u04AF\u0439");
@@ -1133,6 +1257,24 @@ var ResponseValidator = class {
       parsedSubject: parseSubject(leaf)
     };
   }
+  /**
+   * Certificate-choice session-ий хариуг шалгана: COMPLETE/OK (эс бөгөөс `SessionFailedError`), гэрчилгээ ба
+   * documentNumber байгаа, хугацаа, certLevel, зориулалт (гарын үсгийн — contentCommitment, `checkKeyUsage` үед), гинж,
+   * issuer. Энэ хариунд гарын үсэг БАЙХГҮЙ — иргэнийг таниагүй (нэвтрэлт биш); зөвхөн дараагийн sign session-ий
+   * гэрчилгээг урьдчилж мэдэхэд. `sessionId` — certificate-choice session.
+   */
+  validateCertificateChoice(result, sessionId = null) {
+    this.sessionDone(result);
+    const leaf = this.leafOf(result, "RAW_DIGEST_SIGNATURE");
+    return {
+      documentNumber: result.documentNumber,
+      certificate: leaf,
+      certificateDerB64: leaf.raw.toString("base64"),
+      certificateLevel: String(result.certificateLevel ?? ""),
+      parsedSubject: parseSubject(leaf),
+      certChoiceSessionId: sessionId
+    };
+  }
   /**
    * Хариуны signatureAlgorithm + hashAlgorithm-ийг RP-ийн хүссэнтэй ба иргэний түлхүүрийн төрөлтэй тулгана
    * (downgrade / alg confusion хаалт).
@@ -1182,13 +1324,22 @@ var ResponseValidator = class {
   // ── дотоод ──
   /** state/endResult, cert байгаа эсэх, chain, validity, certLevel — нийтлэг шалгалт. */
   precheck(result, protocol) {
-    if (result.state !== "COMPLETE") throw new ValidationError(`Session \u0434\u0443\u0443\u0441\u0430\u0430\u0433\u04AF\u0439 (state=${result.state})`);
-    if (result.endResult !== "OK") throw new SessionFailedError(result.endResult ?? "UNKNOWN");
+    this.sessionDone(result);
     if (result.signatureProtocol && result.signatureProtocol !== protocol) {
       throw new ValidationError(`signatureProtocol ${result.signatureProtocol} \u2260 ${protocol}`);
     }
     if (!result.certificateDerB64) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0430\u043B\u0433\u0430");
     if (!result.signatureValueB64) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 \u0433\u0430\u0440\u044B\u043D \u04AF\u0441\u044D\u0433 \u0430\u043B\u0433\u0430");
+    return this.leafOf(result, protocol);
+  }
+  /** COMPLETE + OK; амжилтгүй endResult → SessionFailedError. */
+  sessionDone(result) {
+    if (result.state !== "COMPLETE") throw new ValidationError(`Session \u0434\u0443\u0443\u0441\u0430\u0430\u0433\u04AF\u0439 (state=${result.state})`);
+    if (result.endResult !== "OK") throw new SessionFailedError(result.endResult ?? "UNKNOWN");
+  }
+  /** Хариуны гэрчилгээ: documentNumber, задлалт, хугацаа, certLevel, зориулалт (protocol), гинж, issuer. */
+  leafOf(result, protocol) {
+    if (!result.certificateDerB64) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 \u0433\u044D\u0440\u0447\u0438\u043B\u0433\u044D\u044D \u0430\u043B\u0433\u0430");
     if (!result.documentNumber) throw new ValidationError("\u0425\u0430\u0440\u0438\u0443\u043D\u0434 documentNumber \u0430\u043B\u0433\u0430");
     const leaf = new X509Certificate3(Buffer.from(result.certificateDerB64, "base64"));
     this.checkValidity(leaf);
@@ -1590,6 +1741,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);
@@ -1603,7 +1756,7 @@ var EidClient = class {
     });
     const level = cfg.defaultCertificateLevel ?? "QUALIFIED";
     this.auth = new AuthApi(http, cfg.credentials, { certificateLevel: level });
-    this.sign = new SignApi(http, cfg.credentials, { certificateLevel: level });
+    this.sign = new SignApi(http, cfg.credentials, { certificateLevel: level, sessionTtlMs: cfg.signSessionTtlMs });
     this.pdf = new PdfApi(http, cfg.credentials, {
       certificateLevel: level,
       timeoutMs: cfg.pdfTimeoutMs ?? DEFAULT_PDF_TIMEOUT_MS,
@@ -1614,6 +1767,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;
   }
 };
 
@@ -1678,6 +1832,37 @@ function buildDeviceLink(p) {
   const authCode = createHmac("sha256", Buffer.from(p.sessionSecret, "base64")).update(payload, "utf8").digest("base64url");
   return `${unprotected}&authCode=${authCode}`;
 }
+function deviceLinkInput(s, deviceLinkType, lang) {
+  const base = {
+    deviceLinkBase: s.deviceLinkBase ?? "",
+    deviceLinkType,
+    sessionToken: s.sessionToken ?? "",
+    sessionSecret: s.sessionSecret ?? "",
+    lang,
+    receivedAt: s.receivedAt
+  };
+  if (s.sessionType === "sign" && s.sign) {
+    return {
+      ...base,
+      sessionType: "sign",
+      digest: s.sign.digest,
+      relyingPartyName: s.sign.relyingPartyName,
+      interactions: s.sign.interactions,
+      initialCallbackUrl: s.sign.initialCallbackUrl
+    };
+  }
+  if (s.sessionType === "cert") {
+    return { ...base, sessionType: "cert", relyingPartyName: s.relyingPartyName ?? "", interactions: "" };
+  }
+  return {
+    ...base,
+    sessionType: "auth",
+    rpChallenge: s.acsp?.rpChallenge ?? s.rpChallenge,
+    relyingPartyName: s.acsp?.relyingPartyName ?? "",
+    interactions: s.acsp?.interactions ?? "",
+    initialCallbackUrl: s.acsp?.initialCallbackUrl ?? ""
+  };
+}
 function qrDeviceLinkTicker(input, onLink, opts) {
   const clock = opts?.clock ?? Date.now;
   const tick = () => onLink(buildDeviceLink({ ...input, deviceLinkType: "QR", now: clock() }));
@@ -1687,293 +1872,392 @@ 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";
+function forwardedClientIp(headers, trustProxy) {
+  if (trustProxy === false || trustProxy === 0) return void 0;
+  const xff = header(headers, "x-forwarded-for").split(",").map((x) => x.trim()).filter(Boolean);
+  if (xff.length) {
+    if (trustProxy === true) return xff[0];
+    const n = Math.floor(trustProxy);
+    return n >= 1 && n <= xff.length ? xff[xff.length - n] : void 0;
+  }
+  return header(headers, "x-real-ip").trim() || void 0;
+}
+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(sessionId, r, v, flowType) {
+  const s = v.parsedSubject;
+  const etsi = s.serialNumber ?? "";
+  const m = /^PNOMN-([0-9]+)$/.exec(etsi);
+  return {
+    sessionId,
+    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");
-    }
-    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");
+  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 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);
+    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 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(this.tokenEndpoint(d), {
-      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 = {};
+    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" });
+    const ip = req.ip || (opts.trustProxy ? forwardedClientIp(req.headers, opts.trustProxy) : void 0);
+    if (ip && !await rateLimit(`start:${ip}`)) return limited();
+    if (mode === "push" && !await rateLimit(`push:${idCode}`)) return limited();
+    let r;
     try {
-      j = await res.json();
-    } catch {
+      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" });
     }
-    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
-      );
+    if (mode === "web2app") {
+      return { status: 302, headers: { Location: r.appLink, "Cache-Control": "no-store", "Referrer-Policy": "no-referrer", "Set-Cookie": r.setCookie }, body: "" };
     }
-    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");
+    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(tx.sessionId, 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 {
+      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" });
     }
-    return j.id_token;
-  }
-  /** Code солих endpoint: `useMtlsEndpointAliases` + alias байвал alias (RFC 8705 §5), эс бөгөөс `token_endpoint`. */
-  tokenEndpoint(d) {
-    if (!this.cfg.useMtlsEndpointAliases) return d.token_endpoint;
-    const alias = d.mtls_endpoint_aliases?.token_endpoint;
-    if (alias === void 0) return d.token_endpoint;
-    if (typeof alias !== "string" || !alias.startsWith("https://")) {
-      throw new EidOidcError("discovery_failed", "OIDC discovery: mtls_endpoint_aliases.token_endpoint \u0431\u0443\u0440\u0443\u0443");
+    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 });
     }
-    return alias;
-  }
-  /**
-   * 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;
+    if (tx.mode === "web2app") return json(200, { state: "WAIT_CALLBACK" });
     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;
+      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 });
     }
-    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}`);
+  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 {
-      return await res.json();
-    } catch {
-      throw new EidOidcError("discovery_failed", `OIDC JSON \u0431\u0438\u0448: ${url}`);
+      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");
     }
-  }
-  async fetch(url, init) {
-    const f = this.cfg.fetchImpl ?? fetch;
-    const req = {
-      ...init,
-      redirect: "error",
-      signal: AbortSignal.timeout(this.cfg.timeoutMs ?? DEFAULT_TIMEOUT_MS2)
-    };
-    if (this.cfg.dispatcher) req.dispatcher = this.cfg.dispatcher;
     try {
-      return await f(url, req);
+      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) {
-      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, ctx);
+      if (!(e instanceof ValidationError || e instanceof SessionFailedError)) return fail2("internal");
+      await store.delete(tx.sessionId);
+      return fail2("VALIDATION");
     }
   }
-};
-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 handleRequest(req) {
+    const seg = new URL(req.url, "http://x").pathname.replace(/\/+$/, "").split("/").pop();
+    try {
+      if (seg === "start") return await start(req);
+      if (seg === "status") return await status(req);
+      if (seg === "callback") return await callback(req);
+    } catch (e) {
+      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" });
+  }
+  let warnedNoIp = false;
+  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 ip = opts.getClientIp?.(req) || void 0;
+    if (!ip && !opts.getClientIp && !opts.trustProxy && !warnedNoIp) {
+      warnedNoIp = true;
+      onError(new Error("eid-login: handle(Request)-\u0434 \u043A\u043B\u0438\u0435\u043D\u0442 IP \u0430\u043B\u0433\u0430 \u2014 `start:<ip>` \u0445\u044F\u0437\u0433\u0430\u0430\u0440 \u0430\u0436\u0438\u043B\u043B\u0430\u0445\u0433\u04AF\u0439; getClientIp \u044D\u0441\u0432\u044D\u043B trustProxy \u04E9\u0433"), {
+        request: { method: req.method, url: req.url, headers },
+        mode: "qr"
+      });
+    }
+    const r = await handleRequest({ method: req.method, url: req.url, headers, body, ip });
+    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,
@@ -1983,14 +2267,10 @@ export {
   DEFAULT_BASE_URL,
   DEFAULT_PDF_MAX_BYTES,
   DEFAULT_PDF_TIMEOUT_MS,
+  DEFAULT_SIGN_SESSION_TTL_MS,
   DeviceLinkError,
-  EID_ACR_ADVANCED,
-  EID_ACR_QUALIFIED,
-  EID_OIDC_ISSUER,
   EidClient,
   EidError,
-  EidOidcClient,
-  EidOidcError,
   ForbiddenError,
   Http,
   NetworkError,
@@ -2009,23 +2289,28 @@ export {
   acspV2Digest,
   buildAcspV2Payload,
   buildDeviceLink,
+  createEidLogin,
   deviceLink,
+  deviceLinkInput,
+  forwardedClientIp,
   interactionsToBase64,
   isMobileUserAgent,
+  memoryLoginStore,
   openOrShowQR,
   parseRetryAfter,
   parseSessionResult,
   parseSubject,
   personMatchesCertificate,
-  pkceChallenge,
   qrDeviceLinkTicker,
   randomChallenge,
   resolveBaseUrl,
+  sessionExpiry,
   sha256Base64,
   tokenAuthDigest,
   tokenLimitOf,
   userChallengeOf,
   verifyPayloadSignature,
   verifyPrehashedSignature,
-  verifyTokenCertificates
+  verifyTokenCertificates,
+  withReturnHint
 };