@atlasauth/js 0.1.0

package/dist/redirect.d.ts

@@ -0,0 +1,38 @@
+/**
+ * §6.3 step 3 / §7.1: completing a redirect-based sign-in.
+ *
+ * OAuth and hosted-page sign-ins finish by redirecting the browser back to the
+ * customer's app with params appended to the URL:
+ *   - `__atlas_attempt` — the sign-in attempt id (always present)
+ *   - `__atlas_ticket`  — a one-time, 60-second ticket to exchange for cookies
+ *   - `__atlas_status`  — the attempt status, present when a step REMAINS
+ *
+ * A ticket means the sign-in is complete and may be turned into a session. A
+ * status WITHOUT a ticket (e.g. `needs_second_factor`) means the server
+ * deliberately withheld the session because a factor is still owed — the client
+ * must not treat that as signed-in. Parsing this is pure and lives here so both
+ * the React provider and any custom integration read the exact same contract.
+ */
+export declare const REDIRECT_PARAMS: readonly ["__atlas_attempt", "__atlas_ticket", "__atlas_status"];
+export interface RedirectResult {
+    attemptId: string;
+    /** Present only when the sign-in completed — exchange it for cookies. */
+    ticket?: string;
+    /** Present when a step remains (e.g. `needs_second_factor`); no session yet. */
+    status?: string;
+}
+/**
+ * Read Atlas's redirect params from a query string (`window.location.search`).
+ *
+ * Returns null when this is not an Atlas redirect: an `__atlas_attempt` on its
+ * own — with neither a ticket nor a status — is not actionable and is treated
+ * as absent, so a stray param cannot put the SDK into a half-state.
+ */
+export declare function readRedirectResult(search: string): RedirectResult | null;
+/**
+ * Return `href` with every Atlas redirect param removed, leaving the customer's
+ * own query intact. Called after handling a redirect so a reload — or a link
+ * copied from the address bar — cannot replay a spent ticket or resurrect a
+ * stale status.
+ */
+export declare function stripRedirectParams(href: string): string;

package/dist/redirect.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * §6.3 step 3 / §7.1: completing a redirect-based sign-in.
+ *
+ * OAuth and hosted-page sign-ins finish by redirecting the browser back to the
+ * customer's app with params appended to the URL:
+ *   - `__atlas_attempt` — the sign-in attempt id (always present)
+ *   - `__atlas_ticket`  — a one-time, 60-second ticket to exchange for cookies
+ *   - `__atlas_status`  — the attempt status, present when a step REMAINS
+ *
+ * A ticket means the sign-in is complete and may be turned into a session. A
+ * status WITHOUT a ticket (e.g. `needs_second_factor`) means the server
+ * deliberately withheld the session because a factor is still owed — the client
+ * must not treat that as signed-in. Parsing this is pure and lives here so both
+ * the React provider and any custom integration read the exact same contract.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REDIRECT_PARAMS = void 0;
+exports.readRedirectResult = readRedirectResult;
+exports.stripRedirectParams = stripRedirectParams;
+exports.REDIRECT_PARAMS = ['__atlas_attempt', '__atlas_ticket', '__atlas_status'];
+/**
+ * Read Atlas's redirect params from a query string (`window.location.search`).
+ *
+ * Returns null when this is not an Atlas redirect: an `__atlas_attempt` on its
+ * own — with neither a ticket nor a status — is not actionable and is treated
+ * as absent, so a stray param cannot put the SDK into a half-state.
+ */
+function readRedirectResult(search) {
+    const params = new URLSearchParams(search);
+    const attemptId = params.get('__atlas_attempt');
+    if (!attemptId)
+        return null;
+    const ticket = params.get('__atlas_ticket');
+    const status = params.get('__atlas_status');
+    if (!ticket && !status)
+        return null;
+    return {
+        attemptId,
+        ...(ticket ? { ticket } : {}),
+        ...(status ? { status } : {}),
+    };
+}
+/**
+ * Return `href` with every Atlas redirect param removed, leaving the customer's
+ * own query intact. Called after handling a redirect so a reload — or a link
+ * copied from the address bar — cannot replay a spent ticket or resurrect a
+ * stale status.
+ */
+function stripRedirectParams(href) {
+    const url = new URL(href);
+    for (const key of exports.REDIRECT_PARAMS)
+        url.searchParams.delete(key);
+    return url.toString();
+}
+//# sourceMappingURL=redirect.js.map

package/dist/redirect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"redirect.js","sourceRoot":"","sources":["../src/redirect.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAmBH,gDAcC;AAQD,kDAIC;AA3CY,QAAA,eAAe,GAAG,CAAC,iBAAiB,EAAE,gBAAgB,EAAE,gBAAgB,CAAU,CAAC;AAUhG;;;;;;GAMG;AACH,SAAgB,kBAAkB,CAAC,MAAc;IAC/C,MAAM,MAAM,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC;IAC3C,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;IAChD,IAAI,CAAC,SAAS;QAAE,OAAO,IAAI,CAAC;IAE5B,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAC5C,MAAM,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;IAC5C,IAAI,CAAC,MAAM,IAAI,CAAC,MAAM;QAAE,OAAO,IAAI,CAAC;IAEpC,OAAO;QACL,SAAS;QACT,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7B,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAC9B,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,mBAAmB,CAAC,IAAY;IAC9C,MAAM,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;IAC1B,KAAK,MAAM,GAAG,IAAI,uBAAe;QAAE,GAAG,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAChE,OAAO,GAAG,CAAC,QAAQ,EAAE,CAAC;AACxB,CAAC"}

package/dist/siwe.d.ts

@@ -0,0 +1,23 @@
+/**
+ * §6 Sign-in with Ethereum (SIWE, EIP-4361) — the client half.
+ *
+ * Two steps, both pure shapers (the app owns fetch):
+ *   1. POST `/v1/oauth/siwe/nonce` (no body) and read the nonce with
+ *      `parseSiweNonceResponse`.
+ *   2. Have the wallet sign an EIP-4361 message carrying that nonce, then POST
+ *      `siweVerifyBody({ message, signature })` to `/v1/oauth/siwe/verify` and
+ *      read the result with the shared `parseNativeSignInResponse`.
+ */
+export interface SiweVerifyBody {
+    message: string;
+    signature: string;
+}
+/** Build the POST body for `/v1/oauth/siwe/verify`. */
+export declare function siweVerifyBody(input: {
+    message: string;
+    signature: string;
+}): SiweVerifyBody;
+/** The single-use nonce returned by `/v1/oauth/siwe/nonce`, or null if malformed. */
+export declare function parseSiweNonceResponse(body: unknown): {
+    nonce: string;
+} | null;

package/dist/siwe.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * §6 Sign-in with Ethereum (SIWE, EIP-4361) — the client half.
+ *
+ * Two steps, both pure shapers (the app owns fetch):
+ *   1. POST `/v1/oauth/siwe/nonce` (no body) and read the nonce with
+ *      `parseSiweNonceResponse`.
+ *   2. Have the wallet sign an EIP-4361 message carrying that nonce, then POST
+ *      `siweVerifyBody({ message, signature })` to `/v1/oauth/siwe/verify` and
+ *      read the result with the shared `parseNativeSignInResponse`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.siweVerifyBody = siweVerifyBody;
+exports.parseSiweNonceResponse = parseSiweNonceResponse;
+/** Build the POST body for `/v1/oauth/siwe/verify`. */
+function siweVerifyBody(input) {
+    return { message: input.message, signature: input.signature };
+}
+/** The single-use nonce returned by `/v1/oauth/siwe/nonce`, or null if malformed. */
+function parseSiweNonceResponse(body) {
+    if (!body || typeof body !== 'object')
+        return null;
+    const b = body;
+    if (typeof b.nonce !== 'string' || b.nonce.length === 0)
+        return null;
+    return { nonce: b.nonce };
+}
+//# sourceMappingURL=siwe.js.map

package/dist/siwe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"siwe.js","sourceRoot":"","sources":["../src/siwe.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAQH,wCAEC;AAGD,wDAKC;AAXD,uDAAuD;AACvD,SAAgB,cAAc,CAAC,KAA6C;IAC1E,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,SAAS,EAAE,KAAK,CAAC,SAAS,EAAE,CAAC;AAChE,CAAC;AAED,qFAAqF;AACrF,SAAgB,sBAAsB,CAAC,IAAa;IAClD,IAAI,CAAC,IAAI,IAAI,OAAO,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACnD,MAAM,CAAC,GAAG,IAA2B,CAAC;IACtC,IAAI,OAAO,CAAC,CAAC,KAAK,KAAK,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACrE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;AAC5B,CAAC"}

package/dist/tab-election.d.ts

@@ -0,0 +1,68 @@
+/**
+ * §7.4: "a BroadcastChannel elects one refreshing tab."
+ *
+ * Twenty open tabs must produce ONE refresh, not twenty. That is not only a
+ * load concern: refresh tokens rotate (§7.4 step 2), so twenty simultaneous
+ * refreshes send the same token twenty times, nineteen of them land outside the
+ * grace window, and the session is revoked for token reuse. Getting this wrong
+ * does not degrade the experience — it signs the user out.
+ *
+ * The election is deliberately simple. A tab that wants to refresh announces a
+ * claim carrying a random id and a timestamp; the lowest id within the claim
+ * window wins. No consensus protocol, because the cost of getting it wrong is
+ * bounded: two tabs refreshing within the 30-second grace window is exactly the
+ * race the grace window exists to absorb.
+ *
+ * BroadcastChannel is missing in Safari private mode and older browsers, so
+ * there is a localStorage fallback. A tab with NEITHER refreshes alone, which
+ * is correct — one tab cannot stampede.
+ */
+/** How long a claim stands before it is considered abandoned. */
+export declare const CLAIM_WINDOW_MS = 3000;
+export interface Claim {
+    id: string;
+    at: number;
+}
+/**
+ * Whether `mine` wins against the claims seen so far.
+ *
+ * Lowest id wins, and only claims inside the window count — otherwise a tab
+ * that crashed mid-refresh would block every other tab forever.
+ */
+export declare function winsElection(mine: Claim, others: readonly Claim[], now: number): boolean;
+export interface Channel {
+    post(message: unknown): void;
+    subscribe(handler: (message: unknown) => void): () => void;
+    close(): void;
+}
+/** BroadcastChannel where available. */
+export declare function broadcastChannel(name: string): Channel | null;
+/**
+ * localStorage fallback.
+ *
+ * The `storage` event fires only in OTHER tabs, which is exactly the semantics
+ * needed — a tab does not need to hear its own message. The key is written and
+ * immediately removed so the value never accumulates and a stale claim cannot
+ * outlive the session that made it.
+ */
+export declare function storageChannel(name: string): Channel | null;
+/**
+ * The best channel available, or null.
+ *
+ * Null is a supported state, not a failure: a single tab with no channel
+ * refreshes alone and cannot stampede by definition.
+ */
+export declare function bestChannel(name: string): Channel | null;
+export type RefreshMessage = {
+    type: 'claim';
+    id: string;
+    at: number;
+} | {
+    type: 'refreshed';
+    jwt: string;
+    expiresAt: number;
+    sessionId: string;
+} | {
+    type: 'signed_out';
+};
+export declare function isRefreshMessage(value: unknown): value is RefreshMessage;

package/dist/tab-election.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * §7.4: "a BroadcastChannel elects one refreshing tab."
+ *
+ * Twenty open tabs must produce ONE refresh, not twenty. That is not only a
+ * load concern: refresh tokens rotate (§7.4 step 2), so twenty simultaneous
+ * refreshes send the same token twenty times, nineteen of them land outside the
+ * grace window, and the session is revoked for token reuse. Getting this wrong
+ * does not degrade the experience — it signs the user out.
+ *
+ * The election is deliberately simple. A tab that wants to refresh announces a
+ * claim carrying a random id and a timestamp; the lowest id within the claim
+ * window wins. No consensus protocol, because the cost of getting it wrong is
+ * bounded: two tabs refreshing within the 30-second grace window is exactly the
+ * race the grace window exists to absorb.
+ *
+ * BroadcastChannel is missing in Safari private mode and older browsers, so
+ * there is a localStorage fallback. A tab with NEITHER refreshes alone, which
+ * is correct — one tab cannot stampede.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAIM_WINDOW_MS = void 0;
+exports.winsElection = winsElection;
+exports.broadcastChannel = broadcastChannel;
+exports.storageChannel = storageChannel;
+exports.bestChannel = bestChannel;
+exports.isRefreshMessage = isRefreshMessage;
+/** How long a claim stands before it is considered abandoned. */
+exports.CLAIM_WINDOW_MS = 3_000;
+/**
+ * Whether `mine` wins against the claims seen so far.
+ *
+ * Lowest id wins, and only claims inside the window count — otherwise a tab
+ * that crashed mid-refresh would block every other tab forever.
+ */
+function winsElection(mine, others, now) {
+    const live = others.filter((claim) => now - claim.at < exports.CLAIM_WINDOW_MS);
+    return live.every((claim) => mine.id <= claim.id);
+}
+/** BroadcastChannel where available. */
+function broadcastChannel(name) {
+    if (typeof BroadcastChannel === 'undefined')
+        return null;
+    const channel = new BroadcastChannel(name);
+    return {
+        post: (message) => channel.postMessage(message),
+        subscribe(handler) {
+            const listener = (event) => handler(event.data);
+            channel.addEventListener('message', listener);
+            return () => channel.removeEventListener('message', listener);
+        },
+        close: () => channel.close(),
+    };
+}
+/**
+ * localStorage fallback.
+ *
+ * The `storage` event fires only in OTHER tabs, which is exactly the semantics
+ * needed — a tab does not need to hear its own message. The key is written and
+ * immediately removed so the value never accumulates and a stale claim cannot
+ * outlive the session that made it.
+ */
+function storageChannel(name) {
+    if (typeof window === 'undefined' || typeof window.localStorage === 'undefined')
+        return null;
+    const key = `atlas:${name}`;
+    return {
+        post(message) {
+            try {
+                window.localStorage.setItem(key, JSON.stringify({ message, at: Date.now() }));
+                window.localStorage.removeItem(key);
+            }
+            catch {
+                // A full or disabled localStorage must not break sign-in. Losing
+                // cross-tab coordination degrades to "each tab refreshes for itself",
+                // which the 30-second grace window absorbs.
+            }
+        },
+        subscribe(handler) {
+            const listener = (event) => {
+                if (event.key !== key || !event.newValue)
+                    return;
+                try {
+                    handler(JSON.parse(event.newValue).message);
+                }
+                catch {
+                    // Another script writing to our key is not our problem to crash over.
+                }
+            };
+            window.addEventListener('storage', listener);
+            return () => window.removeEventListener('storage', listener);
+        },
+        close: () => undefined,
+    };
+}
+/**
+ * The best channel available, or null.
+ *
+ * Null is a supported state, not a failure: a single tab with no channel
+ * refreshes alone and cannot stampede by definition.
+ */
+function bestChannel(name) {
+    return broadcastChannel(name) ?? storageChannel(name);
+}
+function isRefreshMessage(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const type = value.type;
+    return type === 'claim' || type === 'refreshed' || type === 'signed_out';
+}
+//# sourceMappingURL=tab-election.js.map

package/dist/tab-election.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tab-election.js","sourceRoot":"","sources":["../src/tab-election.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAgBH,oCAGC;AASD,4CAaC;AAUD,wCA6BC;AAQD,kCAEC;AAOD,4CAIC;AAnGD,iEAAiE;AACpD,QAAA,eAAe,GAAG,KAAK,CAAC;AAOrC;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,IAAW,EAAE,MAAwB,EAAE,GAAW;IAC7E,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,GAAG,GAAG,KAAK,CAAC,EAAE,GAAG,uBAAe,CAAC,CAAC;IACxE,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,CAAC,EAAE,CAAC,CAAC;AACpD,CAAC;AAQD,wCAAwC;AACxC,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,IAAI,OAAO,gBAAgB,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IAEzD,MAAM,OAAO,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAC3C,OAAO;QACL,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC;QAC/C,SAAS,CAAC,OAAO;YACf,MAAM,QAAQ,GAAG,CAAC,KAAmB,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9D,OAAO,CAAC,gBAAgB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC9C,OAAO,GAAG,EAAE,CAAC,OAAO,CAAC,mBAAmB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAChE,CAAC;QACD,KAAK,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE;KAC7B,CAAC;AACJ,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,IAAY;IACzC,IAAI,OAAO,MAAM,KAAK,WAAW,IAAI,OAAO,MAAM,CAAC,YAAY,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IAE7F,MAAM,GAAG,GAAG,SAAS,IAAI,EAAE,CAAC;IAC5B,OAAO;QACL,IAAI,CAAC,OAAO;YACV,IAAI,CAAC;gBACH,MAAM,CAAC,YAAY,CAAC,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;gBAC9E,MAAM,CAAC,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;YACtC,CAAC;YAAC,MAAM,CAAC;gBACP,iEAAiE;gBACjE,sEAAsE;gBACtE,4CAA4C;YAC9C,CAAC;QACH,CAAC;QACD,SAAS,CAAC,OAAO;YACf,MAAM,QAAQ,GAAG,CAAC,KAAmB,EAAE,EAAE;gBACvC,IAAI,KAAK,CAAC,GAAG,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ;oBAAE,OAAO;gBACjD,IAAI,CAAC;oBACH,OAAO,CAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,CAA0B,CAAC,OAAO,CAAC,CAAC;gBACxE,CAAC;gBAAC,MAAM,CAAC;oBACP,sEAAsE;gBACxE,CAAC;YACH,CAAC,CAAC;YACF,MAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;YAC7C,OAAO,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;QAC/D,CAAC;QACD,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS;KACvB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,WAAW,CAAC,IAAY;IACtC,OAAO,gBAAgB,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,IAAI,CAAC,CAAC;AACxD,CAAC;AAOD,SAAgB,gBAAgB,CAAC,KAAc;IAC7C,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,KAAK,CAAC;IACtD,MAAM,IAAI,GAAI,KAA4B,CAAC,IAAI,CAAC;IAChD,OAAO,IAAI,KAAK,OAAO,IAAI,IAAI,KAAK,WAAW,IAAI,IAAI,KAAK,YAAY,CAAC;AAC3E,CAAC"}

package/dist/telegram.d.ts

@@ -0,0 +1,25 @@
+/**
+ * §6 Telegram Login Widget — the client half.
+ *
+ * Like the native / One-Tap helper, the SDK does not own fetch: these are pure
+ * request/response shapers. The Telegram Login Widget calls the page back with a
+ * signed payload object; the app wraps it with `telegramSignInBody`, POSTs it to
+ * `/v1/oauth/telegram`, and reads the result with the shared
+ * `parseNativeSignInResponse` (a `ticket` means complete; a bare status means a
+ * factor is still owed — exactly the same contract as every other flow).
+ */
+export interface TelegramWidgetUser {
+    id: number | string;
+    first_name?: string;
+    last_name?: string;
+    username?: string;
+    photo_url?: string;
+    auth_date: number | string;
+    hash: string;
+    [key: string]: unknown;
+}
+export interface TelegramSignInBody {
+    telegram: TelegramWidgetUser;
+}
+/** Build the POST body for `/v1/oauth/telegram` from the widget's user object. */
+export declare function telegramSignInBody(payload: TelegramWidgetUser): TelegramSignInBody;

package/dist/telegram.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * §6 Telegram Login Widget — the client half.
+ *
+ * Like the native / One-Tap helper, the SDK does not own fetch: these are pure
+ * request/response shapers. The Telegram Login Widget calls the page back with a
+ * signed payload object; the app wraps it with `telegramSignInBody`, POSTs it to
+ * `/v1/oauth/telegram`, and reads the result with the shared
+ * `parseNativeSignInResponse` (a `ticket` means complete; a bare status means a
+ * factor is still owed — exactly the same contract as every other flow).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telegramSignInBody = telegramSignInBody;
+/** Build the POST body for `/v1/oauth/telegram` from the widget's user object. */
+function telegramSignInBody(payload) {
+    return { telegram: payload };
+}
+//# sourceMappingURL=telegram.js.map

package/dist/telegram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"telegram.js","sourceRoot":"","sources":["../src/telegram.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;AAkBH,gDAEC;AAHD,kFAAkF;AAClF,SAAgB,kBAAkB,CAAC,OAA2B;IAC5D,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;AAC/B,CAAC"}

package/dist/telemetry.d.ts

@@ -0,0 +1,125 @@
+/**
+ * §bot — client-side signal collection for the anti-bot pipeline.
+ *
+ * Two collectors, both privacy-preserving and both fully best-effort (they never
+ * throw, and degrade to nulls in any environment):
+ *
+ *   - `collectDeviceSignals()` — a snapshot of the device/environment: screen,
+ *     timezone, hardware, a coarse canvas/WebGL fingerprint, and AUTOMATION
+ *     TELLS (navigator.webdriver, headless markers, Selenium/Puppeteer traces).
+ *   - `BehaviorRecorder` — accumulates interaction TIMING AGGREGATES on the auth
+ *     form: mouse kinematics, keystroke dwell/flight, time-to-submit, scrolls.
+ *     It records COUNTS AND TIMINGS ONLY — never which keys were pressed, never
+ *     field values. There is nothing sensitive to leak.
+ *
+ * `sendTelemetry()` posts a snapshot to `/v1/client/telemetry`. It is
+ * fire-and-forget: a failure resolves `false` and is swallowed, so telemetry can
+ * never interfere with a real sign-in.
+ */
+export interface DeviceSignals {
+    screenWidth: number | null;
+    screenHeight: number | null;
+    colorDepth: number | null;
+    pixelRatio: number | null;
+    timezone: string | null;
+    timezoneOffset: number | null;
+    language: string | null;
+    languages: string[];
+    platform: string | null;
+    hardwareConcurrency: number | null;
+    deviceMemory: number | null;
+    maxTouchPoints: number | null;
+    touchSupport: boolean;
+    cookieEnabled: boolean | null;
+    doNotTrack: boolean | null;
+    webglVendor: string | null;
+    webglRenderer: string | null;
+    pluginCount: number | null;
+    pointerType: string | null;
+    webdriver: boolean;
+    headless: boolean;
+    hasChrome: boolean;
+    webglSoftware: boolean;
+    automationHint: boolean;
+}
+export declare function collectDeviceSignals(): DeviceSignals;
+/** A stable pseudonymous client id, persisted in localStorage. */
+export declare function deviceId(): string | null;
+/** A short client-side fingerprint over the stable device signals. */
+export declare function deviceFingerprint(device: DeviceSignals): string;
+export interface BehaviorSignals {
+    mouseMoves: number;
+    mouseDistance: number;
+    mouseAvgSpeed: number | null;
+    mouseMaxSpeed: number;
+    mouseSpeedVariance: number | null;
+    mouseStraightLineRatio: number | null;
+    keyCount: number;
+    keyAvgDwellMs: number | null;
+    keyAvgFlightMs: number | null;
+    keyDwellVariance: number | null;
+    keyFlightVariance: number | null;
+    pasteCount: number;
+    backspaceCount: number;
+    timeToFirstInteractionMs: number | null;
+    timeToSubmitMs: number | null;
+    focusChanges: number;
+    scrollCount: number;
+    hadPointerMove: boolean;
+    hadKeydown: boolean;
+    interactionCount: number;
+}
+/**
+ * Records interaction TIMINGS on the page/form. Start it when the auth form
+ * mounts; call `snapshot()` at submit. It listens passively and captures no
+ * content — only counts, distances and millisecond timings.
+ */
+export declare class BehaviorRecorder {
+    private readonly start;
+    private firstInteraction;
+    private moves;
+    private distance;
+    private maxSpeed;
+    private speeds;
+    private lastX;
+    private lastY;
+    private lastMoveT;
+    private netDx;
+    private netDy;
+    private keyCount;
+    private downAt;
+    private dwell;
+    private flight;
+    private lastUpAt;
+    private pastes;
+    private backspaces;
+    private focusChanges;
+    private scrolls;
+    private target;
+    private bound;
+    constructor(target?: Document);
+    private mark;
+    private attach;
+    private onMove;
+    private onKeyDown;
+    private onKeyUp;
+    /** A snapshot of aggregates so far. Safe to call repeatedly. */
+    snapshot(): BehaviorSignals;
+    /** Detach all listeners. */
+    stop(): void;
+}
+export interface TelemetryOptions {
+    /** FAPI base, e.g. 'https://accounts.acme.com' or '' for same-origin. */
+    api: string;
+    publishableKey: string;
+    attemptId?: string;
+    kind?: 'sign_in' | 'sign_up' | 'telemetry';
+    recorder?: BehaviorRecorder;
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Collect a device snapshot (+ behaviour from `recorder`, if given) and POST it.
+ * Resolves `true` when the beacon was accepted, `false` otherwise — never
+ * throws. Uses `navigator.sendBeacon` when possible so it survives navigation.
+ */
+export declare function sendTelemetry(opts: TelemetryOptions): Promise<boolean>;