@stopnetic/js 0.1.1 → 0.1.3

package/README.md

@@ -1,5 +1,43 @@
 # @stopnetic/js - JavaScript and TypeScript website guard
 
+## First-party automation mode (unreleased)
+
+Repository server option `botProtection: 'monitor' | 'block'` defaults to `'off'`.
+Environment-based server helpers also support `STOPNETIC_BOT_PROTECTION`.
+This requires the matching service and a new SDK release after 0.1.2. Client
+automation evidence can be hidden; stealth agents may still pass. Public routes
+stay public. No external detection provider is used.
+See [configuration, tests and limits](../../docs/bot-protection.md).
+
+Prepared protocol 2 adds browser-report consistency, fresh server-verified SHA-256
+work and a per-binding verification budget. Modern secure-context Web Crypto is
+required for block mode. Fully concealed browsers doing valid work may still
+pass; monitor records evidence without these additional denials.
+
+Additional prepared hardening observes non-native webdriver getter replacements.
+For Vercel-hosted server guards, optional `botClientSource: 'vercel'` adds shared
+network budgets that survive cookie clearing and SDK worker changes. Use monitor
+first. It needs actual trusted Vercel ingress and the matching service; missing
+metadata withholds private access. The raw IP remains on the customer server;
+a daily, site-scoped HMAC key is used only for short-lived counters, not events.
+Server helpers accept `STOPNETIC_BOT_CLIENT_SOURCE=vercel`. Default source is `none`; no customer database or external detector is required.
+Native-looking low-volume stealth and network rotation can still pass. See the
+linked protection guide for thresholds, shared-network risks and test results.
+
+Prepared `requireApprovedAccount: true` plus a server-side authorizeVisitor
+callback can additionally require the customer's currently approved account for
+every protected request. This is an integration contract, not a login/passkey
+service. See [approved access](../../docs/approved-access.md).
+
+## Verification screen update (unreleased)
+
+The shared guard now prepares a centered Stopnetic-branded verification screen,
+embedded logo, loading indicator and failure/timeout retry message. It uses no
+external assets and keeps protected content withheld. Mobile, reduced-motion and
+JavaScript-disabled browsers have appropriate presentation. Websites need the
+next SDK release and a rebuild/redeployment for this update; publishing or
+deploying the Stopnetic dashboard alone does not change an installed SDK.
+
 Unreleased country controls: server options `countryBlocking: true` and a trusted
 `countrySource` enable the compatible protocol. The `/server` environment helper
 also reads `STOPNETIC_COUNTRY_BLOCKING=true`. Deploy and test guarded requests

package/dist/bot-protection.js

@@ -0,0 +1,51 @@
+import { createHmac } from 'node:crypto';
+import { isIP } from 'node:net';
+
+// Coarse, spoofable observations. No raw user-agent, IP or fingerprint leaves
+// the installation. An empty list is never evidence of a human visitor.
+/** @param {Request} request @param {boolean | null} [webdriver] @param {boolean} [inconsistent] @param {boolean} [tampered] */
+export function automationSignals(request, webdriver = null, inconsistent = false, tampered = false) {
+  const ua = (request.headers.get('user-agent') || '').slice(0, 1024);
+  const signals = [];
+  if (/bot|crawler|spider/i.test(ua)) signals.push('ua_bot');
+  if (/\b(?:curl|wget|python|httpclient|node-fetch|undici|go-http-client|postmanruntime)\b/i.test(ua)) signals.push('ua_script');
+  if (/headless/i.test(ua)) signals.push('ua_headless');
+  if (webdriver === true) signals.push('webdriver');
+  if (inconsistent) signals.push('webdriver_inconsistent');
+  if (tampered) signals.push('webdriver_tampered');
+  return signals;
+}
+
+export function sameBotControl(actual, expected) {
+  return actual?.version === 2 && actual.mode === expected.mode
+    && Array.isArray(actual.signals) && actual.signals.length === expected.signals.length
+    && actual.signals.every((signal, index) => signal === expected.signals[index]);
+}
+
+// Trust only an explicitly configured Vercel ingress. Never fall back to
+// arbitrary X-Forwarded-For, country, cookies or browser-supplied identifiers.
+export function botClientContext(request, source, secret, scope) {
+  if (source === 'none') return {};
+  let network = null;
+  if (process.env.VERCEL === '1') {
+    const raw = (request.headers.get('x-vercel-forwarded-for') || '').trim();
+    const family = raw.length <= 45 && !raw.includes('%') ? isIP(raw) : 0;
+    if (family === 4) network = 'v4:' + raw;
+    if (family === 6) {
+      const canonical = new URL(`http://[${raw}]/`).hostname.slice(1, -1);
+      const [left, right] = canonical.split('::');
+      const head = left ? left.split(':') : [];
+      const tail = right ? right.split(':') : [];
+      const groups = right !== undefined ? [...head, ...Array(8 - head.length - tail.length).fill('0'), ...tail] : head;
+      const words = groups.map(value => parseInt(value, 16));
+      // IPv4-mapped IPv6 must share its IPv4 budget; ordinary IPv6 groups use
+      // /64 so rotating addresses inside one network cannot reset the budget.
+      network = words.slice(0, 5).every(value => value === 0) && words[5] === 65535
+        ? 'v4:' + [words[6] >> 8, words[6] & 255, words[7] >> 8, words[7] & 255].join('.')
+        : 'v6:' + words.slice(0, 4).map(value => value.toString(16).padStart(4, '0')).join(':');
+    }
+  }
+  const epoch = Math.floor(Date.now() / 86400000);
+  return { bot_client: { version: 1, source, key: network === null ? null
+    : createHmac('sha256', secret).update(`stopnetic-network-v1:${scope}:${epoch}:${network}`).digest('hex') } };
+}

package/dist/browser-check.js

@@ -0,0 +1,55 @@
+export const botWorkChallenge = { version: 1, algorithm: 'sha256', difficulty: 12, max_nonce: 1_048_575 };
+
+export function validBotWork(value) {
+  return value && Object.keys(value).length === 4
+    && Object.entries(botWorkChallenge).every(([key, expected]) => value[key] === expected);
+}
+
+// This function is serialized into the nonce-authorized challenge script.
+// These observations can be forged; server-verified work is a separate check.
+export function collectBrowserEvidence() {
+  let webdriver = null;
+  let prototypeValue = null;
+  let webdriverTampered = false;
+  try { if (typeof navigator.webdriver === 'boolean') webdriver = navigator.webdriver; } catch { /* Unavailable, not a bot verdict. */ }
+  try {
+    let prototype = Object.getPrototypeOf(navigator);
+    for (let depth = 0; prototype && depth < 4; depth++, prototype = Object.getPrototypeOf(prototype)) {
+      const descriptor = Object.getOwnPropertyDescriptor(prototype, 'webdriver');
+      if (typeof descriptor?.get === 'function') {
+        // A replaced getter is an observation, not proof of automation.
+        const source = Function.prototype.toString.call(descriptor.get);
+        const value = descriptor.get.call(navigator);
+        if (typeof value === 'boolean') {
+          prototypeValue = value;
+          webdriverTampered = webdriver !== null && !/\{\s*\[native code\]\s*\}/.test(source);
+        }
+        break;
+      }
+    }
+  } catch { /* Privacy tooling and unsupported APIs are not denial evidence. */ }
+  return { webdriver, webdriverInconsistent: webdriver !== null && prototypeValue !== null && webdriver !== prototypeValue, webdriverTampered };
+}
+
+// A bounded, transparent work factor, not proof of humanity. No custom crypto,
+// third-party script, persistent fingerprint or hidden background worker.
+export async function solveBrowserWork(challengeId, signal) {
+  const encoder = new TextEncoder();
+  const started = performance.now();
+  for (let first = 0; first <= 1_048_575; first += 32) {
+    if (signal.aborted || performance.now() - started > 8000) return null;
+    const values = await Promise.all(Array.from({ length: 32 }, async (_, offset) => {
+      const nonce = first + offset;
+      const digest = new Uint8Array(await crypto.subtle.digest('SHA-256', encoder.encode(`stopnetic-work-v1:${challengeId}:${nonce}`)));
+      return digest[0] === 0 && (digest[1] & 240) === 0 ? nonce : null;
+    }));
+    const result = values.find(value => value !== null);
+    if (result !== undefined) return result;
+  }
+  return null;
+}
+
+export function verificationScript(ticket, verifyPath, enabled, challengeId) {
+  const evidence = enabled ? `body.browser=(${collectBrowserEvidence.toString()})();try{const nonce=await (${solveBrowserWork.toString()})(${JSON.stringify(challengeId)},controller.signal);if(nonce!==null)body.proof={version:1,nonce}}catch{}` : '';
+  return `const controller=new AbortController();const timeout=setTimeout(()=>{controller.abort();failed()},12000);document.getElementById('check-retry').addEventListener('click',()=>location.reload());function failed(){document.getElementById('check-spinner').hidden=true;document.getElementById('check-title').textContent='Unable to complete the check';document.getElementById('check-message').textContent='Please try again. If the problem continues, contact the website owner.';document.getElementById('check-retry').hidden=false}async function run(){const body={ticket:${JSON.stringify(ticket)}};${evidence};const result=await fetch(${JSON.stringify(verifyPath)},{method:'POST',credentials:'same-origin',signal:controller.signal,headers:{'content-type':'application/json'},body:JSON.stringify(body)});if(result.ok)location.reload();else failed()}run().catch(failed).finally(()=>clearTimeout(timeout))`;
+}

package/dist/guard.d.ts

@@ -13,6 +13,19 @@ export type StopneticOptions = {
   timeoutMs?: number;
   publicPaths?: string[];
   reportEvents?: boolean;
+  /** Require the customer's server-validated approved account on protected routes.
+   * Rechecked on each request; independent of bot detection. */
+  requireApprovedAccount?: boolean;
+  /** Must validate an active session and explicit approval using trusted server
+   * data. Only literal true grants approval. Never trust a visitor header/flag. */
+  authorizeVisitor?: (request: Request) => boolean | Promise<boolean>;
+  /** First-party, spoofable automation signals on protected routes. Default off.
+   * Monitor records evidence; block requires bounded server-verified work and
+   * rejects detected signals. Neither establishes human identity. */
+  botProtection?: 'off' | 'monitor' | 'block';
+  /** Optional shared network traffic budgets. Vercel-only trusted ingress; raw IP
+   * stays on the customer server. Missing metadata withholds private access. */
+  botClientSource?: 'none' | 'vercel';
   /** Optional coarse request analytics. No raw visitor IP or user-agent is sent. */
   trafficInsights?: boolean;
   /** Opt into country controls; requires trusted countrySource and no publicPaths. */
@@ -25,6 +38,8 @@ export type StopneticOptions = {
 };
 export function parseAdditionalDecisionPublicKeys(value?: string): string[];
 export function createStopnetic(options: StopneticOptions): {
+  /** Local configured capability declaration, not a deployment attestation. */
+  readonly capabilities: { readonly approvedAccountGate: boolean; readonly botProtocol: 2 };
   check(request: Request): Promise<Response | null>;
   verify(request: Request): Promise<Response>;
 };

package/dist/guard.js

@@ -1,6 +1,9 @@
 import { createHash, createHmac, randomBytes, timingSafeEqual, verify as verifySignature } from 'node:crypto';
 import { trustedSigningKeys } from './signing-keys.js';
 import { trafficContext } from './traffic-context.js';
+import { verificationPage } from './verification-page.js';
+import { automationSignals, sameBotControl, botClientContext } from './bot-protection.js';
+import { validBotWork, verificationScript } from './browser-check.js';
 export { parseAdditionalDecisionPublicKeys } from './signing-keys.js';
 
 const unavailable = retryAfter => new Response(null, { status: 503, headers: {
@@ -50,20 +53,19 @@ async function limitedBody(request, maxBytes) {
   return Buffer.concat(chunks, length).toString('utf8');
 }
 
-function bootstrap(ticket, verifyPath) {
+function bootstrap(ticket, verifyPath, botProtection, challengeId) {
   const nonce = randomBytes(16).toString('base64');
-  const script = `fetch(${JSON.stringify(verifyPath)}, {method:'POST', credentials:'same-origin', headers:{'content-type':'application/json'}, body:JSON.stringify({ticket:${JSON.stringify(ticket)}})}).then(r=>{if(r.ok)location.reload()})`;
-  const html = `<!doctype html><html><head><meta charset="utf-8"><title>Checking access</title></head><body><p>Checking access...</p><script nonce="${nonce}">${script}</script></body></html>`;
+  const html = verificationPage(nonce, verificationScript(ticket, verifyPath, botProtection !== 'off', challengeId));
   return new Response(html, { status: 404, headers: {
     'content-type': 'text/html; charset=utf-8', 'cache-control': 'no-store', 'vary': 'Cookie',
-    'content-security-policy': `default-src 'none'; script-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; form-action 'none'`,
+    'content-security-policy': `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; img-src data:; connect-src 'self'; base-uri 'none'; form-action 'none'`,
     'x-content-type-options': 'nosniff',
   } });
 }
 
 /** Pilot guard for server-side Next.js Proxy and Route Handlers. */
 export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, additionalDecisionPublicKeys = [], cookieSecret, verifyPath = '/__stopnetic/verify',
-  cookieName = 'stopnetic_pilot_session', secureCookie = true, fetchImpl = fetch, timeoutMs = 2000, publicPaths = [], reportEvents = true, guardMode = 'selected', trafficInsights = false, countrySource = 'none', countryBlocking = false }) {
+  cookieName = 'stopnetic_pilot_session', secureCookie = true, fetchImpl = fetch, timeoutMs = 2000, publicPaths = [], reportEvents = true, guardMode = 'selected', trafficInsights = false, countrySource = 'none', countryBlocking = false, botProtection = 'off', botClientSource = 'none', requireApprovedAccount = false, authorizeVisitor }) {
   if (!/^[a-z0-9][a-z0-9_-]{0,63}$/.test(siteId || '')) throw new Error('Invalid siteId');
   const credential = typeof apiToken === 'string' ? apiToken.match(/^[a-z]{1,32}_([a-f0-9]{32})\.[A-Za-z0-9_-]{43}$/) : null;
   if (!credential) throw new Error('apiToken must be an issued installation key');
@@ -85,6 +87,13 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
   if (!Array.isArray(publicPaths) || publicPaths.some(path => typeof path !== 'string' || !/^\/[a-zA-Z0-9_\-/.]*(?:\*)?$/.test(path))) throw new Error('Invalid publicPaths');
   if (!['selected', 'site'].includes(guardMode)) throw new Error('Invalid guardMode');
   if (typeof countryBlocking !== 'boolean') throw new Error('Invalid countryBlocking');
+  if (typeof requireApprovedAccount !== 'boolean') throw new Error('Invalid requireApprovedAccount');
+  if (requireApprovedAccount && typeof authorizeVisitor !== 'function') throw new Error('requireApprovedAccount requires a server-side authorizeVisitor function');
+  if (!requireApprovedAccount && authorizeVisitor !== undefined) throw new Error('authorizeVisitor requires requireApprovedAccount');
+  if (requireApprovedAccount && publicPaths.length) throw new Error('requireApprovedAccount requires no publicPaths bypasses');
+  if (!['none', 'vercel'].includes(botClientSource) || (botClientSource !== 'none' && botProtection === 'off')) throw new Error('botClientSource requires an enabled botProtection mode and supported ingress');
+  if (!['off', 'monitor', 'block'].includes(botProtection)) throw new Error('Invalid botProtection');
+  if (botProtection !== 'off' && publicPaths.length) throw new Error('botProtection requires no publicPaths bypasses');
   if (countryBlocking && (countrySource === 'none' || publicPaths.length)) throw new Error('countryBlocking requires an explicit countrySource and no publicPaths bypasses');
   const publicKeys = trustedSigningKeys(decisionPublicKey, additionalDecisionPublicKeys);
   const verifyEndpoint = new URL('./verify', endpoint);
@@ -134,6 +143,39 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
         || (country.result !== 'disabled' && country.revision === null)
         || (!['disabled', 'pass'].includes(country.result) && payload.action !== 'block')) throw new Error('Invalid country decision');
     }
+    if (botProtection !== 'off') {
+      const bot = payload.bot_decision;
+      if (!sameBotControl(payload.bot_control, input.bot_control) || !sameBotControl(bot, input.bot_control)
+        || !Array.isArray(bot.server_signals) || bot.server_signals.length > 5
+        || new Set(bot.server_signals).size !== bot.server_signals.length
+        || !bot.server_signals.every(signal => ['work_missing', 'work_invalid', 'verification_rate', 'request_rate', 'network_verification_rate'].includes(signal))
+        || typeof bot.work_verified !== 'boolean'
+        || !['observe', 'continue', 'block', 'public'].includes(bot.result)
+        || (botProtection === 'monitor' && bot.result !== 'observe')
+        || (botProtection === 'block' && (bot.result === 'observe'
+          || ((input.bot_control.signals.length > 0 || bot.server_signals.length > 0) && bot.result === 'continue')
+          || (purpose === 'verify' && payload.action === 'verified' && !bot.work_verified)))
+        || (bot.result === 'block' && payload.action !== 'block')
+        || (bot.result === 'public' && payload.action !== 'public'
+          && !(payload.action === 'block' && payload.country_decision
+            && !['disabled', 'pass'].includes(payload.country_decision.result)))) throw new Error('Invalid automation decision');
+    }
+    if (botClientSource !== 'none') {
+      const client = payload.bot_client;
+      if (client?.version !== 1 || client.source !== botClientSource || client.key !== input.bot_client?.key) throw new Error('Invalid client rate context');
+    }
+    if (requireApprovedAccount) {
+      const control = payload.approved_access;
+      const approval = payload.approval_decision;
+      const deniedCountry = payload.country_decision && !['disabled', 'pass'].includes(payload.country_decision.result);
+      if (control?.version !== 1 || control.required !== true || control.status !== input.approved_access.status
+        || approval?.version !== 1 || !['public', 'approved', 'required', 'unavailable'].includes(approval.result)
+        || (approval.result === 'approved' && control.status !== 'approved')
+        || (approval.result === 'required' && (control.status !== 'unapproved' || payload.action !== 'block'))
+        || (approval.result === 'unavailable' && (control.status !== 'unavailable' || !deniedCountry || payload.action !== 'block'))
+        || (approval.result === 'public' && payload.action !== 'public' && !(deniedCountry && payload.action === 'block'))
+        || (purpose === 'verify' && payload.action === 'verified' && approval.result !== 'approved')) throw new Error('Invalid account approval decision');
+    }
     return { ...payload, receipt: envelope.decision };
   }
 
@@ -154,6 +196,11 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
     const payload = verified(value, cookieSecret);
     const binding = browserBinding(request);
     return payload?.kind === 'session' && payload.site === siteId && payload.installation === installation
+      && (botProtection === 'off' || (payload.bot_mode === botProtection && payload.bot_version === 2
+        && (typeof payload.webdriver === 'boolean' || payload.webdriver === null)
+        && typeof payload.webdriver_inconsistent === 'boolean' && typeof payload.webdriver_tampered === 'boolean'
+        && (botProtection !== 'block' || payload.work_verified === true)))
+      && (botClientSource === 'none' || (payload.bot_client_key && payload.bot_client_key === clientContext(request).bot_client.key))
       && binding && payload.browser_hash === hash(binding) ? payload : null;
   }
 
@@ -162,6 +209,27 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
       country: trafficContext(request, true, countrySource).country } } : {};
   }
 
+  function clientContext(request) { return botClientContext(request, botClientSource, cookieSecret, `${siteId}:${installationId}`); }
+
+  function botControl(request, webdriver = null, inconsistent = false, tampered = false) {
+    return botProtection === 'off' ? {} : { bot_control: { version: 2, mode: botProtection,
+      signals: automationSignals(request, webdriver, inconsistent, tampered) } };
+  }
+
+  async function approvedAccess(request) {
+    if (!requireApprovedAccount) return {};
+    let status;
+    let timer;
+    try {
+      const result = await Promise.race([Promise.resolve().then(() => authorizeVisitor(request)),
+        new Promise((_, reject) => { timer = setTimeout(() => reject(new Error('Approval unavailable')), timeoutMs); })]);
+      status = result === true ? 'approved' : 'unapproved';
+    }
+    catch { status = 'unavailable'; }
+    finally { clearTimeout(timer); }
+    return { approved_access: { version: 1, required: true, status } };
+  }
+
   async function check(request) {
     const path = new URL(request.url).pathname;
     if (path === verifyPath) return null;
@@ -178,7 +246,7 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
     let policy;
     try {
       const context = trafficContext(request, trafficInsights, countrySource);
-      policy = await remote('decision', { path, method: request.method, ...countryControl(request), ...(context ? { traffic_context: context } : {}), ...(guardMode === 'site' ? { guard_mode: 'site' } : {}), ...(binding ? { browser_binding: binding } : {}),
+      policy = await remote('decision', { path, method: request.method, ...countryControl(request), ...await approvedAccess(request), ...botControl(request, session?.webdriver, session?.webdriver_inconsistent, session?.webdriver_tampered), ...clientContext(request), ...(context ? { traffic_context: context } : {}), ...(guardMode === 'site' ? { guard_mode: 'site' } : {}), ...(binding ? { browser_binding: binding } : {}),
         ...(challenge ? { session_challenge: challenge } : {}) });
     } catch (error) { return unavailable(error?.retryAfter); }
     if (!policy || !['public', 'block', 'human', 'verified', 'entitled', 'default'].includes(policy.action)) return unavailable();
@@ -189,9 +257,13 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
     if (session) { await report(policy, 'ALLOW', true); return null; }
     if (policy.action === 'verified' || !eligible) { await report(policy, 'BLOCK'); return concealed(); }
     if (!/^[A-Za-z0-9_-]{43}$/.test(policy.challenge_id || '')) return unavailable();
+    if (botProtection !== 'off' && !validBotWork(policy.bot_work)) return unavailable();
     const ticket = signed({ v: 1, kind: 'challenge', site: siteId, path, exp: Date.now() + 60_000,
+      ...(requireApprovedAccount ? { approval_required: true } : {}),
+      ...(botClientSource !== 'none' ? { bot_client_key: clientContext(request).bot_client.key } : {}),
+      ...(botProtection !== 'off' ? { bot_mode: botProtection, bot_version: 2 } : {}),
       challenge_id: policy.challenge_id, browser_hash: hash(binding), installation }, cookieSecret);
-    const response = bootstrap(ticket, verifyPath);
+    const response = bootstrap(ticket, verifyPath, botProtection, policy.challenge_id);
     response.headers.set('set-cookie', cookie(browserCookieName, signed({ v: 1, kind: 'browser', site: siteId,
       binding, installation, exp: Date.now() + 600_000 }, cookieSecret), 600));
     await report(policy, 'CHALLENGE');
@@ -212,22 +284,51 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
     let body;
     try { body = await limitedBody(request, 4096); } catch { return concealed(); }
     let ticket;
-    try { ticket = JSON.parse(body).ticket; } catch { return concealed(); }
+    let browser;
+    let proof;
+    try { const input = JSON.parse(body); ticket = input.ticket; browser = input.browser; proof = input.proof; } catch { return concealed(); }
     const payload = verified(ticket, cookieSecret);
     const binding = browserBinding(request);
     if (payload?.kind !== 'challenge' || payload.site !== siteId || payload.installation !== installation
       || typeof payload.path !== 'string' || !/^\/[^\s?#]*$/.test(payload.path) || !binding
       || payload.browser_hash !== hash(binding) || !/^[A-Za-z0-9_-]{43}$/.test(payload.challenge_id || '')) return concealed();
+    if (requireApprovedAccount && payload.approval_required !== true) return concealed();
+    if (botProtection !== 'off' && (payload.bot_mode !== botProtection || payload.bot_version !== 2 || !browser
+      || !Object.hasOwn(browser, 'webdriver') || Object.keys(browser).length !== 3
+      || typeof browser.webdriverTampered !== 'boolean'
+      || typeof browser.webdriverInconsistent !== 'boolean'
+      || !(typeof browser.webdriver === 'boolean' || browser.webdriver === null))) return concealed();
+    if (botProtection !== 'off' && proof !== undefined && (!proof || Object.keys(proof).length !== 2
+      || proof.version !== 1 || !Number.isSafeInteger(proof.nonce) || proof.nonce < 0 || proof.nonce > 1_048_575)) return concealed();
+    if (botClientSource !== 'none') {
+      const client = clientContext(request).bot_client;
+      if (!client.key) return unavailable();
+      if (payload.bot_client_key !== client.key) return concealed();
+    }
+    let workVerified = false;
     try {
-      const result = await remote('verify', { path: payload.path, method: 'POST', challenge_id: payload.challenge_id, browser_binding: binding, ...countryControl(request) });
+      const result = await remote('verify', { path: payload.path, method: 'POST', challenge_id: payload.challenge_id, browser_binding: binding, ...countryControl(request), ...await approvedAccess(request), ...botControl(request, browser?.webdriver, browser?.webdriverInconsistent, browser?.webdriverTampered), ...clientContext(request),
+        ...(botProtection !== 'off' && proof ? { bot_proof: proof } : {}) });
       if (result.action === 'block' && result.country_decision && !['disabled', 'pass'].includes(result.country_decision.result)) {
         await report(result, 'BLOCK');
         return concealed();
       }
+      if (result.action === 'block' && result.bot_decision?.result === 'block') {
+        await report(result, 'BLOCK');
+        return concealed();
+      }
+      if (result.action === 'block' && result.approval_decision?.result === 'required') {
+        await report(result, 'BLOCK');
+        return concealed();
+      }
       if (result.action !== 'verified' || result.challenge_id !== payload.challenge_id) return unavailable();
+      workVerified = result.bot_decision?.work_verified === true;
       await report(result, 'VERIFIED');
     } catch (error) { return unavailable(error?.retryAfter); }
     const session = signed({ v: 1, kind: 'session', site: siteId, installation,
+      ...(botProtection !== 'off' ? { bot_mode: botProtection, bot_version: 2, webdriver: browser.webdriver,
+        webdriver_inconsistent: browser.webdriverInconsistent, webdriver_tampered: browser.webdriverTampered, work_verified: workVerified } : {}),
+      ...(botClientSource !== 'none' ? { bot_client_key: clientContext(request).bot_client.key } : {}),
       browser_hash: hash(binding), challenge_id: payload.challenge_id, challenge_path: payload.path,
       exp: Date.now() + 300_000 }, cookieSecret);
     return new Response(null, { status: 204, headers: {
@@ -236,5 +337,5 @@ export function createStopnetic({ siteId, apiUrl, apiToken, decisionPublicKey, a
     } });
   }
 
-  return { check, verify };
+  return { check, verify, capabilities: Object.freeze({ approvedAccountGate: requireApprovedAccount, botProtocol: 2 }) };
 }

package/dist/server.js

@@ -4,6 +4,7 @@ export const accessBase = '/api/stopnetic';
 
 /** Server environment only. Never import this module into browser code. */
 export function optionsFromEnv(env = process.env) {
+  if (env.STOPNETIC_REQUIRE_APPROVED_ACCOUNT && !['true', 'false'].includes(env.STOPNETIC_REQUIRE_APPROVED_ACCOUNT)) throw new Error('Invalid STOPNETIC_REQUIRE_APPROVED_ACCOUNT');
   return {
     origin: env.STOPNETIC_WEBSITE_ORIGIN,
     siteId: env.STOPNETIC_SITE_ID,
@@ -16,6 +17,9 @@ export function optionsFromEnv(env = process.env) {
     cookieSecret: env.STOPNETIC_COOKIE_SECRET,
     guardMode: 'site',
     trafficInsights: env.STOPNETIC_TRAFFIC_INSIGHTS === 'true',
+    botProtection: env.STOPNETIC_BOT_PROTECTION || 'off',
+    botClientSource: env.STOPNETIC_BOT_CLIENT_SOURCE || 'none',
+    requireApprovedAccount: env.STOPNETIC_REQUIRE_APPROVED_ACCOUNT === 'true',
     countryBlocking: env.STOPNETIC_COUNTRY_BLOCKING === 'true',
     countrySource: env.STOPNETIC_COUNTRY_SOURCE || 'none',
     verifyPath: `${accessBase}/verify`,

package/dist/verification-page.js

@@ -0,0 +1,11 @@
+// The existing StopneticL.png is embedded to avoid an external asset dependency
+// while checking access. Keep this page independent of the protected application.
+const logo = 'data:image/png;base64,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';
+
+export function verificationPage(nonce, script) {
+  return `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><meta name="robots" content="noindex, nofollow"><title>Checking access | Stopnetic</title>
+<style nonce="${nonce}">
+*{box-sizing:border-box}body{margin:0;background:#fafafa;color:#171717;font-family:Arial,Helvetica,sans-serif;-webkit-font-smoothing:antialiased}main{min-height:100vh;min-height:100svh;display:grid;place-items:center;padding:32px 24px}.content{width:100%;max-width:380px;text-align:center}.brand{position:relative;width:184px;aspect-ratio:791/147;overflow:hidden;margin:0 auto 44px}.brand img{position:absolute;width:109.4816687737%;max-width:none;height:auto;left:-4.2983565107%;top:-47.619047619%}.spinner{width:28px;height:28px;margin:0 auto 24px;border:2px solid #e5e5e5;border-top-color:#262626;border-radius:50%;animation:turn .9s linear infinite}h1{margin:0;font-size:22px;font-weight:600;line-height:1.4;letter-spacing:-.4px}p{margin:12px 0 0;font-size:14px;line-height:1.7;color:#666}button{min-height:44px;margin-top:24px;padding:10px 20px;border:1px solid #171717;border-radius:8px;background:#171717;color:white;font:600 14px Arial,Helvetica,sans-serif;cursor:pointer}button:hover{background:#333}button:focus-visible{outline:2px solid #171717;outline-offset:4px}[hidden]{display:none!important}noscript p{margin-top:24px;color:#404040}@keyframes turn{to{transform:rotate(360deg)}}@media(prefers-reduced-motion:reduce){.spinner{animation:none}}
+</style></head><body><main><section class="content" aria-labelledby="check-title"><div class="brand"><img src="${logo}" alt="Stopnetic" width="866" height="288"></div><div class="spinner" id="check-spinner" aria-hidden="true"></div><div role="status" aria-live="polite"><h1 id="check-title">Checking access…</h1><p id="check-message">Please wait while we check your connection.</p></div><button id="check-retry" type="button" hidden>Try again</button><noscript><p>Enable JavaScript and cookies, then reload this page to continue.</p></noscript></section></main><script nonce="${nonce}">${script}</script></body></html>`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stopnetic/js",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Server-side Stopnetic guard for JavaScript websites, Node.js and Express-compatible servers.",
   "type": "module",
   "license": "MIT",