Add optional HF OAuth visitor identity for Protected GPU requests

BETA_TESTING.md

@@ -15,14 +15,16 @@ URL for Protected Spaces. Source access is not required for anonymous CPU use.
 CPU processing and complete browser usability are separate acceptance checks.
 The interface permits GPU on the direct entry when the server reports it available;
 HF still enforces quota. Direct GPU may use the limited anonymous allowance.
-Signed-in visitor account attribution remains unverified and must be separately
-qualified; a completed anonymous GPU run does not establish access to a larger
-account allowance. No extra in-app login or personal-token field is introduced.
+Optional HF sign-in identifies the visitor through an official PKCE flow using
+openid/profile only. Tokens stay in page memory; no personal-token field or app
+password is introduced. Verify HF identity — no GPU checks the same queue/client
+credential path before a run. Hosted OAuth/account-quota acceptance must still
+be qualified for each build; a completed anonymous run is not account attribution.
 
 Before remote testers receive the expanded interface:
 
 1. Freeze an allow-listed clean package and verify its manifest.
-2. Deploy it to the existing private test Space without changing visibility.
+2. Deploy it to the existing Protected test Space without changing visibility.
 3. Verify hosted CPU and one bounded GPU upload → run → download → deletion path
    using disposable, user-owned/generated files. Check HF allowance before GPU.
 4. Confirm recipe persistence/import/export and batch completion/stop in both

DATA_POLICY.md

@@ -16,7 +16,7 @@ uploads and run history are disabled. These restrictions are not secure RAM eras
 
 Each job uses temporary files removed before a successful result is published.
 The application result store is memory-only. No public file URL is created.
-The browser holds a random job access key in memory, not a user account or HF token.
+The browser holds a random job access key in memory, independently of optional HF sign-in.
 Anyone who obtains that key can access the job; do not share it. Reloading the
 page loses access. Expiry is fixed at 30 minutes from result publication.
 
@@ -34,6 +34,24 @@ This is deletion of application-controlled files and stored results, not a claim
 of physical RAM/disk erasure, prevention of swap, or deletion of response buffers.
 No claim is made about hosting-provider logs or infrastructure retention.
 
+Optional HF sign-in uses the official HF OAuth authorization-code/PKCE flow with
+only openid/profile scopes. Credentials and basic profile details live in browser
+page memory, not cookies, localStorage, recipes, or a server session database.
+HF handles password entry and authorization. The callback briefly carries a
+one-use authorization code and state in its URL; the app clears that URL before
+returning to the main window. HF/proxy infrastructure handling is outside this
+application's deletion guarantee. The app does not request email, billing,
+repository access, or persistent bucket access.
+
+A non-GPU queue check forwards the visitor bearer credential to HF's fixed
+userinfo endpoint and returns only the username, PRO flag, and authentication
+path. The queue also receives that visitor credential for GPU calls. Credentials
+are never sent to the native simulator or written to application logs/results.
+HF and framework transient request buffers remain outside secure-erasure claims.
+Sign out clears this page's credential; expiry or closing/reloading the page also
+loses it. Sign out does not revoke the HF OAuth grant or sign out of HF itself;
+users may revoke the grant in HF account settings. CPU does not require sign-in.
+
 Results received by the browser and files saved locally are the user's to manage.
 The browser retains its received result in page memory so Save received result
 again can retry a local save without another server retrieval. Discard browser

FRONTEND_SOURCE.json

@@ -4,5 +4,5 @@
   "output_sha256": "135a0c57be851af2879660ae6584a4bfa0a9280fc33e2c0372bc47b531f1960f",
   "scope": "Frontend only; no engine, private data, track assets, API calls or storage copied",
   "status": "Local candidate: configurable training, browser recipes, bounded sequential batches, browser network editor; track renderer and star evaluation unconnected",
-  "candidate_sha256": "d5c744fadd114d40512ebd5f84294334babe2d36d868d2a7787938cc8c45fec3"
+  "candidate_sha256": "9e5b6bd69dd587f0e5c0f551b291de4d6a729e601916042cde0449ba2162bee8"
 }

README.md

@@ -4,9 +4,11 @@ sdk: gradio
 sdk_version: 6.29.1
 python_version: "3.10"
 app_file: app.py
+hf_oauth: true
+hf_oauth_expiration_minutes: 60
 ---
 
-Private CPU/ZeroGPU integration candidate. Custom interface with Gradio Server on port 7860.
+Protected CPU/ZeroGPU integration candidate. Custom interface with Gradio Server on port 7860.
 Simulator: https://github.com/Zorro909/driving_sim_rs
 Hosting adaptation and UI: TiGa https://github.com/seeker-cyber-maker/driving_sim_rs
 CPU is the default; GPU requests explicitly use ZeroGPU. No automatic fallback. No bundled tracks or networks.
@@ -17,3 +19,5 @@ Expanded runner UI beta candidate: configurable training, settings-only browser
 recipes, bounded sequential batches, browser-local network creation/editing.
 Track rendering and star evaluation are not connected. This new package is
 not hosted-qualified. See BETA_TESTING.md and STORAGE_BOUNDARY.md.
+
+Optional HF OAuth: openid/profile only. CPU remains anonymous. Visitor tokens live in browser memory; queue identity is checked before GPU dispatch. No personal token entry, server session store, or automatic CPU fallback.

RELEASE_MANIFEST.json

@@ -1,30 +1,36 @@
 {
   "backend": "cpu+zerogpu",
   "files": {
-    "BETA_TESTING.md": "d5bfa1c8f634d8ef6851be01c3836ff95628910023a930f90a0f3931b48542b4",
-    "DATA_POLICY.md": "4a0f14d468796c166ccabc0f708a640fb4cd663ebcd7b13d53cfcdd85c10bab1",
-    "FRONTEND_SOURCE.json": "698f111a09d33a5d069583b551726932d7a09cfcc840b221d1c5fedddd42c219",
+    "BETA_TESTING.md": "d511965b9d675a092571f8815348da991ef1ef6be3766266c1f98ff393fd3a4d",
+    "DATA_POLICY.md": "72bf2be8b87d948501ea44cbdcb2d6d7680f7387ed1c39fd1d3afdf094cf5487",
+    "FRONTEND_SOURCE.json": "1e31b153757fd42c3bc2abaa1982a44e19a2ed7dc259d32781f36bb9a3ee10b7",
     "GODOT_LICENSE": "fb2b3bb82c60f1e76841ba2122eb902f8e39c151476fe21ce10c9a05d1045304",
     "IMPORTER_BUILD_RECEIPT.json": "4ba5c533cc617105478e4d85c83f456a7dfa68b1388049624619871ba9e42e9d",
     "LICENSE": "53d5851b6440feeae36f72a5f57fcab37858c48b7084765ece4b0c54b9a28ed8",
-    "README.md": "744a470c043dd650f2ca712f3145307121657fb8dd318711885aba9f0e380153",
-    "STORAGE_BOUNDARY.md": "f16c360c822e9f6d4993fe6704658533c83cc5cfd2ebc5c80730b8d608c6d4df",
-    "app.py": "7f2e38bb7b720f4bebf96444e8002442355a899c88a7780dd22a8b837480c894",
+    "README.md": "11abed635d4192b5ea8d8891fc38e3a60989ad5b4696683d0321f3bc12eba20f",
+    "STORAGE_BOUNDARY.md": "3b91d8db71ece1bb55f38685610d722b162a78af0a602926c16792075e48ef99",
+    "app.py": "704f789a41846b0a5bc1d3f6f5305d7ac5a6b1719ff77c23585b89fd3e68d55d",
     "app_release.py": "7482559c667a665fd3cb6aa8af6c78422a822b515e14589db8306f7fd4860a8b",
     "assets/formula_template.json": "80f745df82bb7be45af52785fd582460bcddc63c5a4e1d8375d85b3122db4c6b",
     "bin/altd-sim": "2f2f2144ae14b0ef599ca8510f95712da00243c6875881491d384b394e7499f7",
     "bin/extract_saved_track": "3a7733c45b4301a786fcbfe92660a1c484749272da5f608d62f34878bd4ff31a",
     "bin/libaltd_gpu.so": "279d6353b4c691686d6aeeae6abfd4a82b959e9b604f079a6c45f9823b48a87a",
-    "client.js": "33ab96f15d053f91513e5a05db2cb3aa3018c1fb86e11aab08a089feb1d68538",
+    "client.js": "79a34470942132a4e4a4100ae92b805ff02f7fe344e7962cfcff6a1208cef54a",
     "delivery.py": "4f5a4e45df92e5cbfdef6eb449ede9ba26217fe24da376fafddae5cbbb73847a",
     "gpu_tickets.py": "c32cb5de751d49d3e1cd970c7d6328a42ebe71602dd9fd3788c872eef42611da",
-    "index.html": "d5c744fadd114d40512ebd5f84294334babe2d36d868d2a7787938cc8c45fec3",
+    "hf-auth-callback.html": "07a753a8a70a145d4fc22ae4b259259f4aa202e3d3ae58b9077d271a8ccb7928",
+    "hf-auth.js": "d39981c98eec48d941a8e8b31b49ba0c44b7debe628c92681dfd26324782e545",
+    "hf_identity.py": "6993d0238ada835606dbdc3275c17a3fe5a5cac5ad2156ab78230acf2d051eba",
+    "index.html": "9e5b6bd69dd587f0e5c0f551b291de4d6a729e601916042cde0449ba2162bee8",
     "requirements.txt": "9b532747e51bd052e82090ece860d6dafe027407f4512dc74272c148ea104c22",
-    "server.py": "87622ef590ea61d0844d012820735b4a9a4ef51dab23c76377474d55dcfb5113",
+    "server.py": "f0fa001000a55503ac62498105cb9f3a3798051582eac27c46b56ff592d5c734",
     "training_config.py": "2b9768876fdc60b16afb45b98023c6c31666e30f7c56f1292f6071775e6da0c5",
     "vendor/gradio-client/LICENSE": "c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4",
     "vendor/gradio-client/dist/index.min.js": "fdd776db8633354f118fe2908c980592283968737e6b91dc3aa86d648da5c3fd",
     "vendor/gradio-client/package.json": "96c5b9e6d3587fb7bd8e5bb28775ece222de1043045afc4e6389c88db137ad0e",
+    "vendor/hf-oauth/LICENSE": "d6e7b19451c1b3d1d66353bb4b1274138953b3bfd9ae60c56e77b1f548796982",
+    "vendor/hf-oauth/index.js": "53282844000a171011e547f6472a3846bb4cecb5071adafea079fcac3a2aee7e",
+    "vendor/hf-oauth/package.json": "fafd4d8891023a1961546a7d3bc25cd24f64923a2ebfc449fe6d516a2949bda8",
     "worker.py": "934fb941a7f73a82c9bbcff5f3290103d4dd55e66542e71d56ae8fe7101f0e57"
   },
   "hosted_verified": false,

STORAGE_BOUNDARY.md

@@ -12,6 +12,7 @@ same settings contract is used independently of the selected storage policy.
 | Single-run output | Memory result store and random job key | Receipt ACK in automatic mode, manual delete, fixed 30-minute expiry, or shutdown |
 | Batch intermediates | Same job contract, always automatic | Verified size/hash and deletion ACK before advancement |
 | Received candidate / receipt | Browser page memory | Explicit discard, replacement, page reload/close; explicit export to disk |
+| Optional HF identity / token / PKCE state | Browser page memory, separate from job/recipe storage | Sign out, expiry, or page reload/close; no app auth cookie or server session database |
 | User bucket | Not implemented | Must require an explicit opt-in adapter and separate retention policy |
 
 `recipes.cjs` has no host/network dependency. Its `createStore(storage)` receives
@@ -21,7 +22,7 @@ bytes to recipe JSON. A public profile must not inherit private persistent
 artifact storage implicitly. Server cleanup must never clear the recipe library;
 clearing recipes must never delete a server job, bucket, or downloaded file.
 
-The current app has no bucket credentials, HF identity storage, telemetry, or
+The current app has no bucket credentials, persistent HF identity storage, telemetry, or
 automatic recipe upload. Browser-local storage is site-specific and may be
 blocked by browser privacy settings. A local runner and an HF iframe do not
 automatically share their library; explicit JSON export/import is the bridge.

app.py

@@ -19,6 +19,7 @@ from gpu_tickets import InputTickets
 from server import create_app
 from worker import run_native,track_input,network_input
 from training_config import validate_config
+from hf_identity import visitor_identity
 
 def build_app(cuda_call):
     base=create_app(worker=cpu_worker)
@@ -86,6 +87,11 @@ def build_app(cuda_call):
             return {**base.state.results.publish(payload,automatic),'backend':'gpu','report':report}
         finally:admission.release()
 
+    @app.api(name='visitor_identity',api_visibility='undocumented')
+    def queue_identity(request:gr.Request)->dict:
+        # Same queue/client credential path, but no GPU decorator or user files.
+        return visitor_identity(request.headers or {})
+
     # Existing download/status/ACK/delete and CPU routes use the same result store.
     for route in base.router.routes:
         if getattr(route,'path',None)!='/api/capabilities':app.router.routes.append(route)

client.js

@@ -14,6 +14,7 @@ let batchReceipt = null;
 const hostedStandalone = location.hostname.endsWith('.hf.space') && window.self === window.top;
 const say = text => { $('status').textContent = text; };
 function buttons() {
+  window.HFAuth?.setBusy(busy || !!job);
   window.setTrainingBusy?.(busy || !!job);
   window.setEditorBusy?.(busy || !!job);
   $('run').disabled = busy || !!job || !capabilitiesReady;
@@ -64,16 +65,33 @@ window.TrainingClient={
 };
 async function submit(body){
   if(body.backend==='gpu' && gpuTransport==='gradio-ticket'){
-    if(!gradioClient){
-      const {Client}=await import('/gradio-client.js');
-      gradioClient=await Client.connect(location.origin);
-    }
+    await verifyGpuIdentity();
     const prepared=await (await request('/api/gpu/prepare',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)})).json();
     const result=await gradioClient.predict('/gpu_train',[prepared.ticket]);
     return result.data[0];
   }
   return (await request('/api/process',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)})).json();
 }
+async function verifyGpuIdentity(){
+  const credentials=window.HFAuth?.credentials()??{};
+  if(!gradioClient){
+    const {Client}=await import('/gradio-client.js');
+    gradioClient=await Client.connect(location.origin,credentials);
+  }
+  const result=await gradioClient.predict('/visitor_identity',[]);
+  window.HFAuth?.verify(result.data[0]);
+  return result.data[0];
+}
+window.addEventListener('hf-auth-change',()=>{
+  const previous=gradioClient;gradioClient=null;
+  if(previous)Promise.resolve(previous.close()).catch(()=>{});
+});
+window.TrainingClient.verifyIdentity=async()=>{
+  if(busy||job)throw Error('Finish the current result before checking identity');
+  busy=true;buttons();
+  try{return await verifyGpuIdentity();}
+  finally{busy=false;buttons();}
+};
 async function receive(current){
   const response=await request('/api/jobs/'+current.id+'/download',{method:'POST',headers:{'X-Job-Key':current.key}});
   const bytes=await response.arrayBuffer();
@@ -226,7 +244,7 @@ async function connect(){
     if(capabilities.cpu!==true)throw new Error('CPU unavailable');
     gpuTransport=capabilities.gpu_transport??null;
     $('gpuOption').disabled=!capabilities.gpu;
-    $('backendNote').textContent=capabilities.gpu?(hostedStandalone?'CPU uses no GPU allowance. Direct GPU requests may use HF’s limited anonymous allowance; signed-in account attribution is not yet verified. No automatic switching.':'CPU uses no GPU allowance. GPU is subject to HF quota through the official client. No automatic switching.'):'CPU available. GPU is not connected on this deployment; no GPU allowance is needed for CPU.';
+    $('backendNote').textContent=capabilities.gpu?(hostedStandalone?'CPU uses no GPU allowance. Optional HF sign-in identifies account GPU requests; without sign-in, direct requests may use the limited anonymous allowance. No automatic switching.':'CPU uses no GPU allowance. GPU is subject to HF quota through the official client; optional HF sign-in explicitly identifies the caller. No automatic switching.'):'CPU available. GPU is not connected on this deployment; no GPU allowance is needed for CPU.';
     capabilitiesReady=true; buttons();
     say('Connected. Choose your track and network, then run the test.');
   } catch(error) {

hf-auth-callback.html

@@ -0,0 +1,12 @@
+<!doctype html><html lang="en"><meta charset="utf-8"><title>HF sign-in return</title>
+<meta name="referrer" content="no-referrer">
+<body><p>Returning sign-in to your training window. If that window was closed, close this tab and sign in again.</p>
+<script>
+'use strict';
+const returnUrl=location.href;
+history.replaceState(null,'','/auth/callback');
+if(window.opener){
+  window.opener.postMessage({type:'hf-oauth-return',url:returnUrl},location.origin);
+  window.close();
+}
+</script></body></html>

hf-auth.js

@@ -0,0 +1,80 @@
+'use strict';
+// Official HF PKCE helpers; nonce/verifier and visitor token live in page RAM only.
+(() => {
+  const node=id=>document.getElementById(id);
+  let session=null,pending=null,locked=false,ready=false,config=null,exchanging=false;
+  const message=text=>{node('hfIdentity').textContent=text;};
+  function render(){
+    node('hfSignIn').disabled=locked||!!pending||!ready;
+    node('hfSignOut').disabled=locked||!!pending||!session;
+    node('hfVerify').disabled=locked||!!pending||!session;
+  }
+  function clear(){session=null;window.dispatchEvent(new Event('hf-auth-change'));render();}
+  window.HFAuth={
+    setBusy(value){locked=value;render();},
+    credentials(){
+      if(pending||exchanging)throw Error('Complete or cancel HF sign-in before starting GPU');
+      if(session && session.accessTokenExpiresAt.getTime()<=Date.now()){
+        clear();message('HF sign-in expired. Sign in again before an account GPU request.');
+        throw Error('HF sign-in expired; sign in again');
+      }
+      return session?{token:session.accessToken}:{};
+    },
+    verify(identity){
+      if(session && (!identity.authenticated||identity.auth_path!=='queue-bearer'||identity.username!==session.userInfo.preferred_username))
+        throw Error('GPU queue visitor identity did not match your HF sign-in; no GPU request started');
+      if(session)message('HF visitor verified through GPU queue: '+identity.username+'. GPU allowance remains subject to HF limits.');
+    }
+  };
+  node('hfSignOut').onclick=()=>{clear();message('Signed out of this app. CPU remains anonymous. HF website sign-in is unchanged.');};
+  node('hfVerify').onclick=async()=>{
+    try{await window.TrainingClient.verifyIdentity();}
+    catch{message('Queue identity check failed. No GPU request started. Sign in again or use CPU.');}
+  };
+  node('hfSignIn').onclick=async()=>{
+    if(locked||pending||!ready)return;
+    const popup=window.open('about:blank','ald-hf-sign-in','popup,width=620,height=760');
+    if(!popup){message('Sign-in window blocked. Allow this sign-in popup or use anonymous CPU.');return;}
+    const state={};
+    pending={popup,state,started:Date.now()};render();
+    try{
+      const helpers=await import('/hf-oauth.js');
+      const url=await helpers.oauthLoginUrl({clientId:config.client_id,scopes:'openid profile',
+        redirectUrl:location.origin+'/auth/callback',localStorage:state});
+      if(!pending || pending.popup!==popup)return;
+      popup.location.href=url;message('Complete the optional sign-in on Hugging Face. No password or personal token is entered here.');
+    }catch{
+      pending=null;popup.close();render();message('HF sign-in could not start. CPU remains available.');
+    }
+  };
+  window.addEventListener('message',async event=>{
+    if(!pending||event.origin!==location.origin||event.source!==pending.popup||event.data?.type!=='hf-oauth-return')return;
+    const flow=pending;pending=null;ready=false;exchanging=true;render();
+    try{
+      const returned=new URL(event.data.url);
+      if(returned.origin!==location.origin||returned.pathname!=='/auth/callback')throw Error();
+      const helpers=await import('/hf-oauth.js');
+      const result=await helpers.oauthHandleRedirect({redirectedUrl:returned.href,
+        nonce:flow.state.nonce,codeVerifier:flow.state.codeVerifier});
+      const scopes=new Set(result.scope.split(/\s+/));
+      if([...scopes].some(scope=>!['openid','profile'].includes(scope)))throw Error();
+      if(!result.accessToken||!result.userInfo.preferred_username||result.accessTokenExpiresAt.getTime()<=Date.now())throw Error();
+      session=result;window.dispatchEvent(new Event('hf-auth-change'));
+      message('Signed in with HF: '+result.userInfo.preferred_username+'. Verify queue identity before GPU use.');
+    }catch{
+      clear();message('HF sign-in was cancelled or could not be verified. No GPU request started; CPU remains available.');
+    }finally{
+      flow.state.nonce=null;flow.state.codeVerifier=null;ready=true;exchanging=false;render();
+    }
+  });
+  setInterval(()=>{
+    if(pending&&(pending.popup.closed||Date.now()-pending.started>300000)){
+      pending.popup.close();pending=null;render();message('HF sign-in window closed or timed out. CPU remains available.');
+    }
+  },1000);
+  fetch('/api/auth/config',{cache:'no-store',credentials:'omit'}).then(async response=>{
+    if(!response.ok)throw Error();config=await response.json();ready=config.enabled===true;render();
+    message(ready?'Optional: sign in with HF to identify account GPU requests. CPU needs no sign-in. Token stays in this page’s memory until sign-out, expiry, or page close.':
+      'HF sign-in is not configured on this deployment. CPU remains anonymous.');
+  }).catch(()=>{message('HF sign-in unavailable. CPU remains anonymous.');render();});
+})();

hf_identity.py

@@ -0,0 +1,32 @@
+"""Read-only visitor identity check; never retain or log bearer credentials."""
+import json
+import os
+from urllib.request import Request, urlopen
+
+
+def oauth_config():
+    client_id = os.environ.get('OAUTH_CLIENT_ID', '')
+    return {'enabled': bool(client_id), 'client_id': client_id,
+            'scopes': 'openid profile'}
+
+
+def visitor_identity(headers):
+    authorization = headers.get('authorization', '')
+    if not authorization:
+        return {'authenticated': False, 'auth_path': 'anonymous'}
+    if not authorization.startswith('Bearer ') or len(authorization) > 8192:
+        raise ValueError('Visitor authentication is invalid; sign in again')
+    # Fixed HF endpoint only: no caller-controlled network destinations.
+    try:
+        request = Request('https://huggingface.co/oauth/userinfo',
+                          headers={'Authorization': authorization})
+        with urlopen(request, timeout=8) as response:
+            profile = json.loads(response.read(65536))
+        username = profile['preferred_username']
+        if not isinstance(username, str) or not username or len(username) > 200:
+            raise ValueError()
+        return {'authenticated': True, 'username': username,
+                'auth_path': 'queue-bearer', 'is_pro': profile.get('isPro') is True}
+    except Exception:
+        # Never echo provider bodies, headers, credentials, or callback URLs.
+        raise ValueError('Visitor identity could not be verified; sign in again') from None

index.html

@@ -2,10 +2,11 @@
 <style>
 :root{color-scheme:dark;font:16px system-ui;background:#0c1420;color:#e5edf5}body{max-width:1320px;margin:auto;padding:28px}h1{font-size:32px;margin:0}h2{font-size:21px;margin:0 0 14px}small,.hint{color:#a2b4c8;line-height:1.6}.grid{display:grid;grid-template-columns:minmax(350px,430px) minmax(0,1fr);gap:24px}.card{background:#152233;border:1px solid #2a3d52;border-radius:16px;padding:22px;margin-top:20px}label{display:block;margin:12px 0 5px}input,select,button{font:inherit;background:#0c1725;color:#e5edf5;border:1px solid #49627c;border-radius:7px;padding:9px}input[type=number],select{width:100%;box-sizing:border-box}input[type=file]{max-width:100%;box-sizing:border-box}button{cursor:pointer}button.primary{background:#62dfb1;color:#102522;font-weight:700}button:disabled{opacity:.4;cursor:default}.row{display:grid;grid-template-columns:1fr 1fr;gap:15px}.reward{display:grid;grid-template-columns:1.7fr 1fr 70px 30px;gap:5px;margin:8px 0}.reward input{width:70px;box-sizing:border-box}a{color:#7ce4c3}canvas{width:100%;background:#09111b;border-radius:10px}#status{white-space:pre-wrap;line-height:1.7}table{width:100%;text-align:left;border-collapse:collapse;font-size:14px}td,th{padding:9px;border-bottom:1px solid #2a3d52}.pill{display:inline-block;background:#284539;border-radius:20px;padding:5px 12px;color:#91efc6;margin:6px 0}#error{color:#ffb5a2;white-space:pre-wrap}.toolbar{display:flex;gap:12px;align-items:center;flex-wrap:wrap;padding-bottom:16px;border-bottom:1px solid #2a3d52;margin-bottom:15px}.run-card{position:sticky;top:20px}details{margin-top:18px;border-top:1px solid #2a3d52;padding-top:14px}summary{cursor:pointer;font-weight:600;color:#c6d9e9}details[open]>summary{margin-bottom:12px}[hidden]{display:none!important}#map_note{font-size:14px}#runs{max-height:380px;overflow:auto}.table-scroll{overflow:auto}@media(max-width:850px){.grid{grid-template-columns:1fr}#drive .grid>section:nth-child(2){order:-1}.run-card{position:static}body{padding:16px}}
 .tabs{display:flex;flex-wrap:wrap;gap:10px;margin:20px 0}.tabs button[aria-selected=true]{background:#62dfb1;color:#102522}.library{display:grid;grid-template-columns:repeat(auto-fit,minmax(260px,1fr));gap:20px}.library input[type=text]{width:100%;box-sizing:border-box}.queue-row{display:flex;gap:8px;margin:8px 0}.queue-row select{flex:1}.pane{min-width:0}.map{min-height:260px;background:#09111b;border-radius:12px;display:flex;flex-direction:column;justify-content:center;align-items:center}pre{white-space:pre-wrap;overflow-wrap:anywhere}input[type=text]{width:100%;box-sizing:border-box}#editor_parameters input{max-width:240px}</style>
-<header><h1>AI Learns To Drive</h1><p class="hint">Simulator by Zorro909 · UI and HF implementation by TiGa (seeker-cyber-maker).</p><p><a href="https://github.com/Zorro909/driving_sim_rs">Upstream simulator</a> · <a href="https://github.com/seeker-cyber-maker/driving_sim_rs">Implementation fork</a> · <a href="https://store.steampowered.com/app/3312030/AI_Learns_To_Drive/">Game by ActivationFunction on Steam</a></p><p role="status">Runner interface migration candidate — configurable single-run training, browser-local recipes and bounded batches. Network inspection and editing run in your browser. Track rendering and star evaluation are not connected.</p><p><a href="https://tiga-rce-ald-tao-gpu.hf.space/" target="_blank" rel="noopener noreferrer">Open the Protected beta app</a> · Share this app address with testers; the HF repository page remains restricted. CPU uses no GPU allowance. GPU is subject to HF quota and may use the limited anonymous allowance here; signed-in account attribution is not yet verified. No personal token or extra login is requested.</p></header>
+<header><h1>AI Learns To Drive</h1><p class="hint">Simulator by Zorro909 · UI and HF implementation by TiGa (seeker-cyber-maker).</p><p><a href="https://github.com/Zorro909/driving_sim_rs">Upstream simulator</a> · <a href="https://github.com/seeker-cyber-maker/driving_sim_rs">Implementation fork</a> · <a href="https://store.steampowered.com/app/3312030/AI_Learns_To_Drive/">Game by ActivationFunction on Steam</a></p><p role="status">Runner interface migration candidate — configurable single-run training, browser-local recipes and bounded batches. Network inspection and editing run in your browser. Track rendering and star evaluation are not connected.</p><p><a href="https://tiga-rce-ald-tao-gpu.hf.space/" target="_blank" rel="noopener noreferrer">Open the Protected beta app</a> · Share this app address with testers; the HF repository page remains restricted. CPU is anonymous. Optional HF sign-in identifies account GPU requests; otherwise the limited anonymous allowance may apply. No personal token entry is requested.</p></header>
 <nav class="tabs" aria-label="Lab sections"><button data-tab="drive" aria-selected="true">1 · Drive & view</button><button data-tab="training" aria-selected="false">2 · Training runs & presets</button><button data-tab="batch" aria-selected="false">3 · Batches</button><button data-tab="editor" aria-selected="false">4 · Network editor</button></nav><div id="drive" class="pane"><div class="grid"><section class="card"><h2>Simulation</h2><p>Training uses the settings on the Training runs & presets tab. Formula networks, steering and acceleration; speed and raycast sensors. Supported networks: Formula, steering and acceleration, speed/raycast sensors, 2–4 layers with up to 16 nodes.</p>
 <p><label for="backend">Compute</label><select id="backend" disabled><option value="cpu">CPU — no GPU allowance</option><option id="gpuOption" value="gpu" disabled>GPU — uses GPU allowance</option></select></p><p id="backendNote" class="hint">Checking available backends…</p>
 <button id="retry" type="button">Retry connection</button>
+<p><button id="hfSignIn" type="button" disabled>Sign in with Hugging Face</button> <button id="hfSignOut" type="button" disabled>Sign out of this app</button> <button id="hfVerify" type="button" disabled>Verify HF identity — no GPU</button></p><p id="hfIdentity" role="status" class="hint">CPU needs no sign-in. Checking optional HF sign-in…</p>
 <p><label>Track (.track) <input id="track" type="file" accept=".track"></label></p>
 <p><label>Formula network (.evolution) <input id="network" type="file" accept=".evolution"></label></p>
 <p id="networkChoice" role="status">Choose an uploaded file or use a network from the browser editor.</p><p><label><input id="automatic" type="checkbox" checked> Automatically delete server-side job data after receiving the result</label></p>
@@ -287,7 +288,7 @@
     message('Batch '+batch.slot+' loaded. Loading a batch does not start it.');
   });
 })();
-</script><script src="/client.js"></script><script>'use strict';
+</script><script src="/client.js"></script><script src="/hf-auth.js"></script><script>'use strict';
 // Navigation only. Editor and training/storage adapters are separate layers.
 document.querySelectorAll('[data-tab]').forEach(button=>button.addEventListener('click',()=>{
   document.querySelectorAll('.pane').forEach(pane=>pane.hidden=pane.id!==button.dataset.tab);

server.py

@@ -4,17 +4,29 @@ import json
 from pathlib import Path
 import threading
 from fastapi import HTTPException, Request
-from fastapi.responses import FileResponse, Response, HTMLResponse
+from fastapi.responses import FileResponse, Response, HTMLResponse, JSONResponse
 from starlette.concurrency import run_in_threadpool
 from delivery import create_api, CapacityExceeded
 from worker import run_reported
 from training_config import validate_config
+from hf_identity import oauth_config
 
 ROOT=Path(__file__).resolve().parent
 
 def create_app(worker=run_reported,store=None,gpu_worker=None):
     app=create_api(store)
     admission=threading.BoundedSemaphore(1)
+    @app.get('/api/auth/config')
+    def auth_config():
+        return JSONResponse(oauth_config(),headers={'Cache-Control':'no-store'})
+    @app.get('/auth/callback')
+    def auth_callback():
+        return FileResponse(ROOT/'hf-auth-callback.html',media_type='text/html',
+            headers={'Cache-Control':'no-store','Referrer-Policy':'no-referrer'})
+    @app.get('/hf-auth.js')
+    def auth_script(): return FileResponse(ROOT/'hf-auth.js',media_type='text/javascript')
+    @app.get('/hf-oauth.js')
+    def oauth_script(): return FileResponse(ROOT/'vendor/hf-oauth/index.js',media_type='text/javascript')
     @app.get('/api/capabilities')
     def capabilities():
         return {'cpu':True,'gpu':gpu_worker is not None,'default':'cpu','configurable_training':True}

vendor/hf-oauth/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Hugging Face
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vendor/hf-oauth/index.js

@@ -0,0 +1,2738 @@
+// ../../../hf-oauth-build-pRp19k/node_modules/gearhash-jit/dist/esm/wasm.js
+var INPUT_OFFSET = 4096;
+var PAGES = 8;
+var MAX_INPUT_SIZE = PAGES * 65536 - INPUT_OFFSET;
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/compress.js
+function compress(cv, cvOff, block, blockOff, out, outOff, full, counter, blockLen, flags) {
+  let m0 = block[blockOff] | 0;
+  let m1 = block[blockOff + 1] | 0;
+  let m2 = block[blockOff + 2] | 0;
+  let m3 = block[blockOff + 3] | 0;
+  let m4 = block[blockOff + 4] | 0;
+  let m5 = block[blockOff + 5] | 0;
+  let m6 = block[blockOff + 6] | 0;
+  let m7 = block[blockOff + 7] | 0;
+  let m8 = block[blockOff + 8] | 0;
+  let m9 = block[blockOff + 9] | 0;
+  let m10 = block[blockOff + 10] | 0;
+  let m11 = block[blockOff + 11] | 0;
+  let m12 = block[blockOff + 12] | 0;
+  let m13 = block[blockOff + 13] | 0;
+  let m14 = block[blockOff + 14] | 0;
+  let m15 = block[blockOff + 15] | 0;
+  let s0 = cv[cvOff] | 0;
+  let s1 = cv[cvOff + 1] | 0;
+  let s2 = cv[cvOff + 2] | 0;
+  let s3 = cv[cvOff + 3] | 0;
+  let s4 = cv[cvOff + 4] | 0;
+  let s5 = cv[cvOff + 5] | 0;
+  let s6 = cv[cvOff + 6] | 0;
+  let s7 = cv[cvOff + 7] | 0;
+  let s8 = 1779033703;
+  let s9 = 3144134277;
+  let s10 = 1013904242;
+  let s11 = 2773480762;
+  let s12 = counter | 0;
+  let s13 = counter / 4294967296 | 0;
+  let s14 = blockLen | 0;
+  let s15 = flags | 0;
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  {
+    const t0 = m0, t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  {
+    const t0 = m0, t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  {
+    const t0 = m0, t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  {
+    const t0 = m0, t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  {
+    const t0 = m0, t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  {
+    const t0 = m0, t1 = m1;
+    m0 = m2;
+    m2 = m3;
+    m3 = m10;
+    m10 = m12;
+    m12 = m9;
+    m9 = m11;
+    m11 = m5;
+    m5 = t0;
+    m1 = m6;
+    m6 = m4;
+    m4 = m7;
+    m7 = m13;
+    m13 = m14;
+    m14 = m15;
+    m15 = m8;
+    m8 = t1;
+  }
+  s0 = (s0 + s4 | 0) + m0 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 16 | s12 << 16;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 12 | s4 << 20;
+  s0 = (s0 + s4 | 0) + m1 | 0;
+  s12 ^= s0;
+  s12 = s12 >>> 8 | s12 << 24;
+  s8 = s8 + s12 | 0;
+  s4 ^= s8;
+  s4 = s4 >>> 7 | s4 << 25;
+  s1 = (s1 + s5 | 0) + m2 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 16 | s13 << 16;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 12 | s5 << 20;
+  s1 = (s1 + s5 | 0) + m3 | 0;
+  s13 ^= s1;
+  s13 = s13 >>> 8 | s13 << 24;
+  s9 = s9 + s13 | 0;
+  s5 ^= s9;
+  s5 = s5 >>> 7 | s5 << 25;
+  s2 = (s2 + s6 | 0) + m4 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 16 | s14 << 16;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 12 | s6 << 20;
+  s2 = (s2 + s6 | 0) + m5 | 0;
+  s14 ^= s2;
+  s14 = s14 >>> 8 | s14 << 24;
+  s10 = s10 + s14 | 0;
+  s6 ^= s10;
+  s6 = s6 >>> 7 | s6 << 25;
+  s3 = (s3 + s7 | 0) + m6 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 16 | s15 << 16;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 12 | s7 << 20;
+  s3 = (s3 + s7 | 0) + m7 | 0;
+  s15 ^= s3;
+  s15 = s15 >>> 8 | s15 << 24;
+  s11 = s11 + s15 | 0;
+  s7 ^= s11;
+  s7 = s7 >>> 7 | s7 << 25;
+  s0 = (s0 + s5 | 0) + m8 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 16 | s15 << 16;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 12 | s5 << 20;
+  s0 = (s0 + s5 | 0) + m9 | 0;
+  s15 ^= s0;
+  s15 = s15 >>> 8 | s15 << 24;
+  s10 = s10 + s15 | 0;
+  s5 ^= s10;
+  s5 = s5 >>> 7 | s5 << 25;
+  s1 = (s1 + s6 | 0) + m10 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 16 | s12 << 16;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 12 | s6 << 20;
+  s1 = (s1 + s6 | 0) + m11 | 0;
+  s12 ^= s1;
+  s12 = s12 >>> 8 | s12 << 24;
+  s11 = s11 + s12 | 0;
+  s6 ^= s11;
+  s6 = s6 >>> 7 | s6 << 25;
+  s2 = (s2 + s7 | 0) + m12 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 16 | s13 << 16;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 12 | s7 << 20;
+  s2 = (s2 + s7 | 0) + m13 | 0;
+  s13 ^= s2;
+  s13 = s13 >>> 8 | s13 << 24;
+  s8 = s8 + s13 | 0;
+  s7 ^= s8;
+  s7 = s7 >>> 7 | s7 << 25;
+  s3 = (s3 + s4 | 0) + m14 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 16 | s14 << 16;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 12 | s4 << 20;
+  s3 = (s3 + s4 | 0) + m15 | 0;
+  s14 ^= s3;
+  s14 = s14 >>> 8 | s14 << 24;
+  s9 = s9 + s14 | 0;
+  s4 ^= s9;
+  s4 = s4 >>> 7 | s4 << 25;
+  if (full) {
+    out[outOff + 8] = s8 ^ cv[cvOff];
+    out[outOff + 9] = s9 ^ cv[cvOff + 1];
+    out[outOff + 10] = s10 ^ cv[cvOff + 2];
+    out[outOff + 11] = s11 ^ cv[cvOff + 3];
+    out[outOff + 12] = s12 ^ cv[cvOff + 4];
+    out[outOff + 13] = s13 ^ cv[cvOff + 5];
+    out[outOff + 14] = s14 ^ cv[cvOff + 6];
+    out[outOff + 15] = s15 ^ cv[cvOff + 7];
+  }
+  out[outOff] = s0 ^ s8;
+  out[outOff + 1] = s1 ^ s9;
+  out[outOff + 2] = s2 ^ s10;
+  out[outOff + 3] = s3 ^ s11;
+  out[outOff + 4] = s4 ^ s12;
+  out[outOff + 5] = s5 ^ s13;
+  out[outOff + 6] = s6 ^ s14;
+  out[outOff + 7] = s7 ^ s15;
+}
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/constants.js
+var IV = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+var CHUNK_START = 1;
+var CHUNK_END = 1 << 1;
+var PARENT = 1 << 2;
+var ROOT = 1 << 3;
+var KEYED_HASH = 1 << 4;
+var DERIVE_KEY_CONTEXT = 1 << 5;
+var DERIVE_KEY_MATERIAL = 1 << 6;
+var OUT_LEN = 32;
+var KEY_LEN = 32;
+var BLOCK_LEN = 64;
+var CHUNK_LEN = 1024;
+var MAX_DEPTH = 54;
+var PERMUTATIONS = new Uint8Array([
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  2,
+  6,
+  3,
+  10,
+  7,
+  0,
+  4,
+  13,
+  1,
+  11,
+  12,
+  5,
+  9,
+  14,
+  15,
+  8,
+  3,
+  4,
+  10,
+  12,
+  13,
+  2,
+  7,
+  14,
+  6,
+  5,
+  9,
+  0,
+  11,
+  15,
+  8,
+  1,
+  10,
+  7,
+  12,
+  9,
+  14,
+  3,
+  13,
+  15,
+  4,
+  0,
+  11,
+  2,
+  5,
+  8,
+  1,
+  6,
+  12,
+  13,
+  9,
+  11,
+  15,
+  10,
+  14,
+  8,
+  7,
+  2,
+  5,
+  3,
+  0,
+  1,
+  6,
+  4,
+  9,
+  14,
+  11,
+  5,
+  8,
+  12,
+  15,
+  1,
+  13,
+  3,
+  0,
+  10,
+  2,
+  6,
+  4,
+  7,
+  11,
+  15,
+  5,
+  0,
+  1,
+  9,
+  8,
+  6,
+  14,
+  10,
+  2,
+  12,
+  3,
+  4,
+  7,
+  13
+]);
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/utils.js
+var IS_LITTLE_ENDIAN = new Uint8Array(new Uint32Array([16909060]).buffer)[0] === 4;
+function readLittleEndianWordsFull(input, offset, words) {
+  for (let i = 0; i < 16; ++i, offset += 4) {
+    words[i] = input[offset] | input[offset + 1] << 8 | input[offset + 2] << 16 | input[offset + 3] << 24;
+  }
+}
+function writeLittleEndianBytesPartial(words, wordOffset, output, byteOffset, byteCount) {
+  const fullWords = byteCount >>> 2;
+  let i = 0;
+  for (; i < fullWords; ++i, byteOffset += 4) {
+    const w = words[wordOffset + i];
+    output[byteOffset] = w & 255;
+    output[byteOffset + 1] = w >>> 8 & 255;
+    output[byteOffset + 2] = w >>> 16 & 255;
+    output[byteOffset + 3] = w >>> 24 & 255;
+  }
+  const remaining = byteCount & 3;
+  if (remaining > 0) {
+    const w = words[wordOffset + i];
+    output[byteOffset] = w & 255;
+    if (remaining > 1)
+      output[byteOffset + 1] = w >>> 8 & 255;
+    if (remaining > 2)
+      output[byteOffset + 2] = w >>> 16 & 255;
+  }
+}
+function encodeUTF8(str) {
+  if (typeof TextEncoder !== "undefined") {
+    return new TextEncoder().encode(str);
+  }
+  const bytes = [];
+  for (let i = 0; i < str.length; i++) {
+    let c = str.charCodeAt(i);
+    if (c < 128) {
+      bytes.push(c);
+    } else if (c < 2048) {
+      bytes.push(192 | c >> 6, 128 | c & 63);
+    } else if (c < 55296 || c >= 57344) {
+      bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+    } else {
+      i++;
+      c = 65536 + ((c & 1023) << 10 | str.charCodeAt(i) & 1023);
+      bytes.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
+    }
+  }
+  return new Uint8Array(bytes);
+}
+var CTZ32_TABLE = new Uint8Array([
+  0,
+  1,
+  28,
+  2,
+  29,
+  14,
+  24,
+  3,
+  30,
+  22,
+  20,
+  15,
+  25,
+  17,
+  4,
+  8,
+  31,
+  27,
+  13,
+  23,
+  21,
+  19,
+  16,
+  7,
+  26,
+  12,
+  18,
+  6,
+  11,
+  5,
+  10,
+  9
+]);
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/hasher.js
+var XofReader = class {
+  inputCv;
+  blockWords;
+  counter;
+  blockLen;
+  flags;
+  outputBlock;
+  outputBlockOffset;
+  constructor(inputCv, blockWords, counter, blockLen, flags) {
+    this.inputCv = inputCv;
+    this.blockWords = blockWords;
+    this.counter = counter;
+    this.blockLen = blockLen;
+    this.flags = flags | ROOT;
+    this.outputBlock = new Uint32Array(16);
+    this.outputBlockOffset = 64;
+  }
+  /**
+   * Read the next `length` bytes of output.
+   */
+  read(length) {
+    const output = new Uint8Array(length);
+    let outputOffset = 0;
+    while (outputOffset < length) {
+      if (this.outputBlockOffset >= 64) {
+        compress(
+          this.inputCv,
+          0,
+          this.blockWords,
+          0,
+          this.outputBlock,
+          0,
+          true,
+          // full 64-byte output
+          this.counter++,
+          this.blockLen,
+          this.flags
+        );
+        this.outputBlockOffset = 0;
+      }
+      const available = 64 - this.outputBlockOffset;
+      const toCopy = Math.min(available, length - outputOffset);
+      const wordOffset = this.outputBlockOffset >>> 2;
+      const byteWithinWord = this.outputBlockOffset & 3;
+      if (byteWithinWord === 0 && toCopy >= 4) {
+        const fullWords = toCopy >>> 2;
+        writeLittleEndianBytesPartial(this.outputBlock, wordOffset, output, outputOffset, fullWords << 2);
+        const bytesCopied = fullWords << 2;
+        outputOffset += bytesCopied;
+        this.outputBlockOffset += bytesCopied;
+      } else {
+        for (let i = 0; i < toCopy; i++) {
+          const wordIdx = this.outputBlockOffset + i >>> 2;
+          const byteIdx = this.outputBlockOffset + i & 3;
+          output[outputOffset + i] = this.outputBlock[wordIdx] >>> (byteIdx << 3) & 255;
+        }
+        outputOffset += toCopy;
+        this.outputBlockOffset += toCopy;
+      }
+    }
+    return output;
+  }
+};
+var ChunkState = class {
+  chainingValue;
+  chunkCounter;
+  blockWords;
+  blockLen;
+  blocksCompressed;
+  flags;
+  constructor(keyWords, chunkCounter, flags) {
+    this.chainingValue = new Uint32Array(keyWords);
+    this.chunkCounter = chunkCounter;
+    this.blockWords = new Uint32Array(16);
+    this.blockLen = 0;
+    this.blocksCompressed = 0;
+    this.flags = flags;
+  }
+  resetTo(keyWords, chunkCounter, flags) {
+    this.chainingValue.set(keyWords);
+    this.chunkCounter = chunkCounter;
+    this.blockLen = 0;
+    this.blocksCompressed = 0;
+    this.flags = flags;
+  }
+  /**
+   * Get the flags for the current block.
+   */
+  startFlag() {
+    return this.blocksCompressed === 0 ? CHUNK_START : 0;
+  }
+  /**
+   * Update the chunk state with input data.
+   * Returns the number of bytes consumed.
+   */
+  update(input, inputOffset, inputLen) {
+    let consumed = 0;
+    while (inputLen > 0) {
+      if (this.blockLen === BLOCK_LEN) {
+        compress(this.chainingValue, 0, this.blockWords, 0, this.chainingValue, 0, false, this.chunkCounter, BLOCK_LEN, this.flags | this.startFlag());
+        this.blocksCompressed++;
+        this.blockLen = 0;
+      }
+      const want = BLOCK_LEN - this.blockLen;
+      const take = Math.min(want, inputLen);
+      if (this.blockLen === 0 && take === BLOCK_LEN) {
+        readLittleEndianWordsFull(input, inputOffset, this.blockWords);
+      } else {
+        for (let i = 0; i < take; i++) {
+          const pos = this.blockLen + i;
+          const wordIdx = pos >>> 2;
+          const byteIdx = pos & 3;
+          if (byteIdx === 0) {
+            this.blockWords[wordIdx] = input[inputOffset + i];
+          } else {
+            this.blockWords[wordIdx] |= input[inputOffset + i] << (byteIdx << 3);
+          }
+        }
+      }
+      this.blockLen += take;
+      inputOffset += take;
+      inputLen -= take;
+      consumed += take;
+    }
+    return consumed;
+  }
+  /**
+   * Finalize this chunk and return its output.
+   * Returns 8 words (chaining value) or 16 words (if root).
+   */
+  output() {
+    const usedWords = this.blockLen + 3 >>> 2;
+    for (let i = usedWords; i < 16; i++) {
+      this.blockWords[i] = 0;
+    }
+    return {
+      inputCv: this.chainingValue,
+      blockWords: this.blockWords,
+      blockLen: this.blockLen,
+      counter: this.chunkCounter,
+      flags: this.flags | this.startFlag() | CHUNK_END
+    };
+  }
+  /**
+   * Get the number of bytes in this chunk.
+   */
+  len() {
+    return this.blocksCompressed * BLOCK_LEN + this.blockLen;
+  }
+};
+var Hasher = class _Hasher {
+  chunkState;
+  keyWords;
+  cvStack;
+  cvStackLen;
+  flags;
+  parentBlock;
+  parentCv;
+  chunkCv;
+  outWords;
+  finalizeCv;
+  /**
+   * Create a new Hasher.
+   *
+   * @param keyWords - Initial key words (IV for regular hashing)
+   * @param flags - Domain separation flags
+   */
+  constructor(keyWords, flags) {
+    this.keyWords = keyWords ? new Uint32Array(keyWords) : new Uint32Array(IV);
+    this.flags = flags ?? 0;
+    this.chunkState = new ChunkState(this.keyWords, 0, this.flags);
+    this.cvStack = new Uint32Array(MAX_DEPTH * 8);
+    this.cvStackLen = 0;
+    this.parentBlock = new Uint32Array(16);
+    this.parentCv = new Uint32Array(8);
+    this.chunkCv = new Uint32Array(8);
+    this.outWords = new Uint32Array(16);
+    this.finalizeCv = new Uint32Array(8);
+  }
+  /**
+   * Reset the hasher to process a new message with the same key/flags.
+   * Reuses all internal buffers — zero allocations.
+   */
+  reset() {
+    this.chunkState.resetTo(this.keyWords, 0, this.flags);
+    this.cvStackLen = 0;
+    return this;
+  }
+  /**
+   * Create a new keyed hasher (MAC).
+   *
+   * @param key - 32-byte key
+   */
+  static newKeyed(key) {
+    if (key.length !== KEY_LEN) {
+      throw new Error(`Key must be ${KEY_LEN} bytes, got ${key.length}`);
+    }
+    const keyWords = new Uint32Array(8);
+    if (IS_LITTLE_ENDIAN) {
+      const view = new Uint32Array(key.buffer, key.byteOffset, 8);
+      keyWords.set(view);
+    } else {
+      for (let i = 0; i < 8; i++) {
+        const off = i * 4;
+        keyWords[i] = key[off] | key[off + 1] << 8 | key[off + 2] << 16 | key[off + 3] << 24;
+      }
+    }
+    return new _Hasher(keyWords, KEYED_HASH);
+  }
+  /**
+   * Create a new key derivation hasher.
+   *
+   * @param context - Context string for domain separation
+   */
+  static newDeriveKey(context) {
+    const contextBytes = encodeUTF8(context);
+    const contextHasher = new _Hasher(new Uint32Array(IV), DERIVE_KEY_CONTEXT);
+    contextHasher.update(contextBytes);
+    const contextKey = new Uint32Array(8);
+    const output = contextHasher.finalizeOutput();
+    compress(output.inputCv, 0, output.blockWords, 0, contextKey, 0, false, output.counter, output.blockLen, output.flags | ROOT);
+    return new _Hasher(contextKey, DERIVE_KEY_MATERIAL);
+  }
+  /**
+   * Push a chaining value onto the stack.
+   */
+  pushCv(cv, cvOffset) {
+    this.cvStack.set(cv.subarray(cvOffset, cvOffset + 8), this.cvStackLen * 8);
+    this.cvStackLen++;
+  }
+  /**
+   * Pop a chaining value from the stack.
+   */
+  popCv(out, outOffset) {
+    this.cvStackLen--;
+    out.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), outOffset);
+  }
+  /**
+   * Add a chunk's chaining value and merge completed subtrees.
+   */
+  addChunkCv(newCv, newCvOffset, totalChunks) {
+    const parentBlock = this.parentBlock;
+    const parentCv = this.parentCv;
+    while ((totalChunks & 1) === 0) {
+      this.popCv(parentBlock, 0);
+      parentBlock.set(newCv.subarray(newCvOffset, newCvOffset + 8), 8);
+      compress(this.keyWords, 0, parentBlock, 0, parentCv, 0, false, 0, BLOCK_LEN, this.flags | PARENT);
+      newCv = parentCv;
+      newCvOffset = 0;
+      totalChunks >>>= 1;
+    }
+    this.pushCv(newCv, newCvOffset);
+  }
+  /**
+   * Update the hasher with input data.
+   *
+   * @param input - Data to hash
+   * @returns this (for chaining)
+   */
+  update(input) {
+    let inputOffset = 0;
+    let inputLen = input.length;
+    while (inputLen > 0) {
+      if (this.chunkState.len() === CHUNK_LEN) {
+        const output = this.chunkState.output();
+        const chunkCv = this.chunkCv;
+        compress(output.inputCv, 0, output.blockWords, 0, chunkCv, 0, false, output.counter, output.blockLen, output.flags);
+        const totalChunks = this.chunkState.chunkCounter + 1;
+        this.addChunkCv(chunkCv, 0, totalChunks);
+        this.chunkState.resetTo(this.keyWords, totalChunks, this.flags);
+      }
+      const want = CHUNK_LEN - this.chunkState.len();
+      const take = Math.min(want, inputLen);
+      this.chunkState.update(input, inputOffset, take);
+      inputOffset += take;
+      inputLen -= take;
+    }
+    return this;
+  }
+  /**
+   * Get the output parameters (for XOF mode or finalization).
+   */
+  finalizeOutput() {
+    let output = this.chunkState.output();
+    let parentBlock = this.parentBlock;
+    let cv = this.finalizeCv;
+    if (this.cvStackLen > 0) {
+      compress(output.inputCv, 0, output.blockWords, 0, cv, 0, false, output.counter, output.blockLen, output.flags);
+      while (this.cvStackLen > 0) {
+        this.cvStackLen--;
+        parentBlock.set(this.cvStack.subarray(this.cvStackLen * 8, (this.cvStackLen + 1) * 8), 0);
+        parentBlock.set(cv, 8);
+        if (this.cvStackLen > 0) {
+          compress(this.keyWords, 0, parentBlock, 0, cv, 0, false, 0, BLOCK_LEN, this.flags | PARENT);
+        } else {
+          return {
+            inputCv: this.keyWords,
+            blockWords: parentBlock,
+            blockLen: BLOCK_LEN,
+            counter: 0,
+            flags: this.flags | PARENT
+          };
+        }
+      }
+    }
+    return output;
+  }
+  /**
+   * Finalize the hash and return the result.
+   *
+   * @param outputLength - Number of bytes to output (default: 32)
+   * @returns The hash output
+   */
+  finalize(outputLength = OUT_LEN) {
+    const output = this.finalizeOutput();
+    const result = new Uint8Array(outputLength);
+    if (outputLength <= 64) {
+      const outWords = this.outWords;
+      compress(
+        output.inputCv,
+        0,
+        output.blockWords,
+        0,
+        outWords,
+        0,
+        outputLength > 32,
+        // full output if > 32 bytes
+        output.counter,
+        output.blockLen,
+        output.flags | ROOT
+      );
+      if (IS_LITTLE_ENDIAN) {
+        const outBytes = new Uint8Array(outWords.buffer);
+        result.set(outBytes.subarray(0, outputLength));
+      } else {
+        writeLittleEndianBytesPartial(outWords, 0, result, 0, outputLength);
+      }
+    } else {
+      const xof = this.finalizeXof();
+      const full = xof.read(outputLength);
+      result.set(full);
+    }
+    return result;
+  }
+  /**
+   * Finalize and return an XOF reader for arbitrary-length output.
+   */
+  finalizeXof() {
+    const output = this.finalizeOutput();
+    return new XofReader(new Uint32Array(output.inputCv), new Uint32Array(output.blockWords), output.counter, output.blockLen, output.flags);
+  }
+};
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/wasm-simd.js
+function toLebU32Min2(n) {
+  return [n & 127 | 128, n >>> 7 & 127];
+}
+function toLebU32Padded5(n) {
+  return [
+    n & 127 | 128,
+    n >>> 7 & 127 | 128,
+    n >>> 14 & 127 | 128,
+    n >>> 21 & 127 | 128,
+    n >>> 28 & 15
+    // Last byte has no continuation bit
+  ];
+}
+function toSignedLeb128_i32(n) {
+  const bytes = [];
+  let value = n | 0;
+  let more = true;
+  while (more) {
+    let byte = value & 127;
+    value >>= 7;
+    if (value === 0 && (byte & 64) === 0 || value === -1 && (byte & 64) !== 0) {
+      more = false;
+    } else {
+      byte |= 128;
+    }
+    bytes.push(byte);
+  }
+  return bytes;
+}
+var MSG_ACCESS_ORDER = [
+  // Round 1: 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  // Round 2: 2,6,3,10,7,0,4,13,1,11,12,5,9,14,15,8
+  2,
+  6,
+  3,
+  10,
+  7,
+  0,
+  4,
+  13,
+  1,
+  11,
+  12,
+  5,
+  9,
+  14,
+  15,
+  8,
+  // Round 3: 3,4,10,12,13,2,7,14,6,5,9,0,11,15,8,1
+  3,
+  4,
+  10,
+  12,
+  13,
+  2,
+  7,
+  14,
+  6,
+  5,
+  9,
+  0,
+  11,
+  15,
+  8,
+  1,
+  // Round 4: 10,7,12,9,14,3,13,15,4,0,11,2,5,8,1,6
+  10,
+  7,
+  12,
+  9,
+  14,
+  3,
+  13,
+  15,
+  4,
+  0,
+  11,
+  2,
+  5,
+  8,
+  1,
+  6,
+  // Round 5: 12,13,9,11,15,10,14,8,7,2,5,3,0,1,6,4
+  12,
+  13,
+  9,
+  11,
+  15,
+  10,
+  14,
+  8,
+  7,
+  2,
+  5,
+  3,
+  0,
+  1,
+  6,
+  4,
+  // Round 6: 9,14,11,5,8,12,15,1,13,3,0,10,2,6,4,7
+  9,
+  14,
+  11,
+  5,
+  8,
+  12,
+  15,
+  1,
+  13,
+  3,
+  0,
+  10,
+  2,
+  6,
+  4,
+  7,
+  // Round 7: 11,15,5,0,1,9,8,6,14,10,2,12,3,4,7,13
+  11,
+  15,
+  5,
+  0,
+  1,
+  9,
+  8,
+  6,
+  14,
+  10,
+  2,
+  12,
+  3,
+  4,
+  7,
+  13
+];
+function generateWasmBytes() {
+  const code = [];
+  function put(bytes) {
+    code.push(...bytes);
+  }
+  put([0, 97, 115, 109]);
+  put([1, 0, 0, 0]);
+  put([1]);
+  put([4]);
+  put([1]);
+  put([96, 0, 0]);
+  put([2]);
+  put([11]);
+  put([1]);
+  put([2, 106, 115]);
+  put([3, 109, 101, 109]);
+  put([2, 0, 1]);
+  put([3]);
+  put([4]);
+  put([3]);
+  put([0]);
+  put([0]);
+  put([0]);
+  put([7]);
+  put([50]);
+  put([3]);
+  put([10]);
+  put([99, 111, 109, 112, 114, 101, 115, 115, 52, 120]);
+  put([0, 0]);
+  put([16]);
+  put([
+    99,
+    111,
+    109,
+    112,
+    114,
+    101,
+    115,
+    115,
+    67,
+    104,
+    117,
+    110,
+    107,
+    115,
+    52,
+    120
+  ]);
+  put([0, 1]);
+  put([14]);
+  put([99, 111, 109, 112, 114, 101, 115, 115, 80, 97, 114, 101, 110, 116]);
+  put([0, 2]);
+  put([10]);
+  const sectionSizeOffset = code.length;
+  put([0, 0, 0, 0, 0]);
+  put([3]);
+  const funcSizeOffset = code.length;
+  put([0, 0, 0, 0, 0]);
+  const funcBodyStart = code.length;
+  put([1]);
+  put([32, 123]);
+  for (let i = 0; i < 16; i++) {
+    put([65, ...toLebU32Min2(i * 16)]);
+    put([253, 0, 2, 0]);
+    put([33, i]);
+  }
+  for (let i = 0; i < 8; i++) {
+    put([65, ...toLebU32Min2(512 + i * 16)]);
+    put([253, 0, 2, 0]);
+    put([33, 16 + i]);
+  }
+  const IV2 = [1779033703, 3144134277, 1013904242, 2773480762];
+  for (let i = 0; i < 4; i++) {
+    const ivBytes = [];
+    for (let j = 0; j < 4; j++) {
+      ivBytes.push(IV2[i] & 255);
+      ivBytes.push(IV2[i] >>> 8 & 255);
+      ivBytes.push(IV2[i] >>> 16 & 255);
+      ivBytes.push(IV2[i] >>> 24 & 255);
+    }
+    put([253, 12, ...ivBytes]);
+    put([33, 24 + i]);
+  }
+  put([65, ...toLebU32Min2(768)]);
+  put([253, 0, 2, 0]);
+  put([33, 28]);
+  put([65, ...toLebU32Min2(784)]);
+  put([253, 0, 2, 0]);
+  put([33, 29]);
+  put([65, ...toLebU32Min2(800)]);
+  put([253, 0, 2, 0]);
+  put([33, 30]);
+  put([65, ...toLebU32Min2(816)]);
+  put([253, 0, 2, 0]);
+  put([33, 31]);
+  let msgIdx = 0;
+  function g(a, b, c, d) {
+    const mx = MSG_ACCESS_ORDER[msgIdx++];
+    const my = MSG_ACCESS_ORDER[msgIdx++];
+    put([32, 16 + a]);
+    put([32, 16 + b]);
+    put([253, 174, 1]);
+    put([32, mx]);
+    put([253, 174, 1]);
+    put([33, 16 + a]);
+    put([32, 16 + d]);
+    put([32, 16 + a]);
+    put([253, 81]);
+    put([34, 16 + d]);
+    put([32, 16 + d]);
+    put([253, 13, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]);
+    put([33, 16 + d]);
+    put([32, 16 + c]);
+    put([32, 16 + d]);
+    put([253, 174, 1]);
+    put([33, 16 + c]);
+    put([32, 16 + b]);
+    put([32, 16 + c]);
+    put([253, 81]);
+    put([34, 16 + b]);
+    put([65, 12]);
+    put([253, 173, 1]);
+    put([32, 16 + b]);
+    put([65, 20]);
+    put([253, 171, 1]);
+    put([253, 80]);
+    put([33, 16 + b]);
+    put([32, 16 + a]);
+    put([32, 16 + b]);
+    put([253, 174, 1]);
+    put([32, my]);
+    put([253, 174, 1]);
+    put([33, 16 + a]);
+    put([32, 16 + d]);
+    put([32, 16 + a]);
+    put([253, 81]);
+    put([34, 16 + d]);
+    put([32, 16 + d]);
+    put([253, 13, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]);
+    put([33, 16 + d]);
+    put([32, 16 + c]);
+    put([32, 16 + d]);
+    put([253, 174, 1]);
+    put([33, 16 + c]);
+    put([32, 16 + b]);
+    put([32, 16 + c]);
+    put([253, 81]);
+    put([34, 16 + b]);
+    put([65, 7]);
+    put([253, 173, 1]);
+    put([32, 16 + b]);
+    put([65, 25]);
+    put([253, 171, 1]);
+    put([253, 80]);
+    put([33, 16 + b]);
+  }
+  for (let round = 0; round < 7; round++) {
+    g(0, 4, 8, 12);
+    g(1, 5, 9, 13);
+    g(2, 6, 10, 14);
+    g(3, 7, 11, 15);
+    g(0, 5, 10, 15);
+    g(1, 6, 11, 12);
+    g(2, 7, 8, 13);
+    g(3, 4, 9, 14);
+  }
+  for (let i = 0; i < 8; i++) {
+    put([65, ...toLebU32Min2(640 + i * 16)]);
+    put([32, 16 + i]);
+    put([32, 24 + i]);
+    put([253, 81]);
+    put([253, 11, 2, 0]);
+  }
+  put([11]);
+  const funcBodySize = code.length - funcBodyStart;
+  const funcSizeBytes = toLebU32Padded5(funcBodySize);
+  for (let i = 0; i < 5; i++) {
+    code[funcSizeOffset + i] = funcSizeBytes[i];
+  }
+  const func1SizeOffset = code.length;
+  put([0, 0, 0, 0, 0]);
+  const func1BodyStart = code.length;
+  const compressChunksBody = generateCompressChunks4xBody();
+  put(compressChunksBody);
+  const func1BodySize = code.length - func1BodyStart;
+  const func1SizeBytes = toLebU32Padded5(func1BodySize);
+  for (let i = 0; i < 5; i++) {
+    code[func1SizeOffset + i] = func1SizeBytes[i];
+  }
+  const func2SizeOffset = code.length;
+  put([0, 0, 0, 0, 0]);
+  const func2BodyStart = code.length;
+  const compressParentBody = generateCompressParentBody();
+  put(compressParentBody);
+  const func2BodySize = code.length - func2BodyStart;
+  const func2SizeBytes = toLebU32Padded5(func2BodySize);
+  for (let i = 0; i < 5; i++) {
+    code[func2SizeOffset + i] = func2SizeBytes[i];
+  }
+  const sectionSize = code.length - sectionSizeOffset - 5;
+  const sectionSizeBytes = toLebU32Padded5(sectionSize);
+  for (let i = 0; i < 5; i++) {
+    code[sectionSizeOffset + i] = sectionSizeBytes[i];
+  }
+  return new Uint8Array(code);
+}
+function generateCompressChunks4xBody() {
+  const code = [];
+  function put(bytes) {
+    code.push(...bytes);
+  }
+  put([2]);
+  put([32, 123]);
+  put([1, 127]);
+  const BATCH_BLOCK_WORDS = SIMD_MEMORY.BATCH_BLOCK_WORDS;
+  const BATCH_CV = SIMD_MEMORY.BATCH_CV;
+  const BATCH_COUNTER_LOW = SIMD_MEMORY.BATCH_COUNTER_LOW;
+  const BATCH_FLAGS_BASE = SIMD_MEMORY.BATCH_FLAGS_BASE;
+  const BATCH_OUTPUT = SIMD_MEMORY.BATCH_OUTPUT;
+  const IV2 = [1779033703, 3144134277, 1013904242, 2773480762];
+  for (let i = 0; i < 8; i++) {
+    put([65, ...toLebU32Min2(BATCH_CV + i * 16)]);
+    put([253, 0, 2, 0]);
+    put([33, 16 + i]);
+  }
+  put([65, 0]);
+  put([33, 32]);
+  put([2, 64]);
+  put([3, 64]);
+  for (let w = 0; w < 16; w++) {
+    put([32, 32]);
+    put([65, ...toLebU32Min2(256)]);
+    put([108]);
+    put([65, ...toLebU32Min2(BATCH_BLOCK_WORDS + w * 16)]);
+    put([106]);
+    put([253, 0, 2, 0]);
+    put([33, w]);
+  }
+  for (let i = 0; i < 4; i++) {
+    const ivBytes = [];
+    for (let j = 0; j < 4; j++) {
+      ivBytes.push(IV2[i] & 255);
+      ivBytes.push(IV2[i] >>> 8 & 255);
+      ivBytes.push(IV2[i] >>> 16 & 255);
+      ivBytes.push(IV2[i] >>> 24 & 255);
+    }
+    put([253, 12, ...ivBytes]);
+    put([33, 24 + i]);
+  }
+  put([65, ...toLebU32Min2(BATCH_COUNTER_LOW)]);
+  put([253, 0, 2, 0]);
+  put([33, 28]);
+  put([253, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+  put([33, 29]);
+  const blockLen64 = [];
+  for (let j = 0; j < 4; j++) {
+    blockLen64.push(64, 0, 0, 0);
+  }
+  put([253, 12, ...blockLen64]);
+  put([33, 30]);
+  put([65, ...toLebU32Min2(BATCH_FLAGS_BASE)]);
+  put([253, 0, 2, 0]);
+  put([32, 32]);
+  put([69]);
+  put([32, 32]);
+  put([65, 15]);
+  put([70]);
+  put([65, 1]);
+  put([116]);
+  put([114]);
+  put([253, 17]);
+  put([253, 80]);
+  put([33, 31]);
+  let msgIdx = 0;
+  function g(a, b, c, d) {
+    const mx = MSG_ACCESS_ORDER[msgIdx++];
+    const my = MSG_ACCESS_ORDER[msgIdx++];
+    put([32, 16 + a]);
+    put([32, 16 + b]);
+    put([253, 174, 1]);
+    put([32, mx]);
+    put([253, 174, 1]);
+    put([33, 16 + a]);
+    put([32, 16 + d]);
+    put([32, 16 + a]);
+    put([253, 81]);
+    put([34, 16 + d]);
+    put([32, 16 + d]);
+    put([253, 13, 2, 3, 0, 1, 6, 7, 4, 5, 10, 11, 8, 9, 14, 15, 12, 13]);
+    put([33, 16 + d]);
+    put([32, 16 + c]);
+    put([32, 16 + d]);
+    put([253, 174, 1]);
+    put([33, 16 + c]);
+    put([32, 16 + b]);
+    put([32, 16 + c]);
+    put([253, 81]);
+    put([34, 16 + b]);
+    put([65, 12]);
+    put([253, 173, 1]);
+    put([32, 16 + b]);
+    put([65, 20]);
+    put([253, 171, 1]);
+    put([253, 80]);
+    put([33, 16 + b]);
+    put([32, 16 + a]);
+    put([32, 16 + b]);
+    put([253, 174, 1]);
+    put([32, my]);
+    put([253, 174, 1]);
+    put([33, 16 + a]);
+    put([32, 16 + d]);
+    put([32, 16 + a]);
+    put([253, 81]);
+    put([34, 16 + d]);
+    put([32, 16 + d]);
+    put([253, 13, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8, 13, 14, 15, 12]);
+    put([33, 16 + d]);
+    put([32, 16 + c]);
+    put([32, 16 + d]);
+    put([253, 174, 1]);
+    put([33, 16 + c]);
+    put([32, 16 + b]);
+    put([32, 16 + c]);
+    put([253, 81]);
+    put([34, 16 + b]);
+    put([65, 7]);
+    put([253, 173, 1]);
+    put([32, 16 + b]);
+    put([65, 25]);
+    put([253, 171, 1]);
+    put([253, 80]);
+    put([33, 16 + b]);
+  }
+  for (let round = 0; round < 7; round++) {
+    g(0, 4, 8, 12);
+    g(1, 5, 9, 13);
+    g(2, 6, 10, 14);
+    g(3, 7, 11, 15);
+    g(0, 5, 10, 15);
+    g(1, 6, 11, 12);
+    g(2, 7, 8, 13);
+    g(3, 4, 9, 14);
+  }
+  for (let i = 0; i < 8; i++) {
+    put([32, 16 + i]);
+    put([32, 24 + i]);
+    put([253, 81]);
+    put([33, 16 + i]);
+  }
+  put([32, 32]);
+  put([65, 1]);
+  put([106]);
+  put([34, 32]);
+  put([65, 16]);
+  put([73]);
+  put([13, 0]);
+  put([11]);
+  put([11]);
+  for (let i = 0; i < 8; i++) {
+    put([65, ...toLebU32Min2(BATCH_OUTPUT + i * 16)]);
+    put([32, 16 + i]);
+    put([253, 11, 2, 0]);
+  }
+  put([11]);
+  return code;
+}
+function generateCompressParentBody() {
+  const code = [];
+  function put(bytes) {
+    code.push(...bytes);
+  }
+  put([1]);
+  put([32, 127]);
+  const PARENT_BLOCK_OFFSET = SIMD_MEMORY.PARENT_BLOCK;
+  const CHUNK_CV_OFFSET = SIMD_MEMORY.CHUNK_CV;
+  const IV2 = [
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ];
+  for (let i = 0; i < 16; i++) {
+    put([65, ...toLebU32Min2(PARENT_BLOCK_OFFSET + i * 4)]);
+    put([40, 2, 0]);
+    put([33, i]);
+  }
+  for (let i = 0; i < 8; i++) {
+    put([65, ...toSignedLeb128_i32(IV2[i])]);
+    put([33, 16 + i]);
+  }
+  for (let i = 0; i < 4; i++) {
+    put([65, ...toSignedLeb128_i32(IV2[i])]);
+    put([33, 24 + i]);
+  }
+  put([65, 0]);
+  put([33, 28]);
+  put([65, 0]);
+  put([33, 29]);
+  put([65, 192, 0]);
+  put([33, 30]);
+  put([65, 4]);
+  put([33, 31]);
+  function g(a, b, c, d, mx, my) {
+    const sa = 16 + a, sb = 16 + b, sc = 16 + c, sd = 16 + d;
+    put([32, sa]);
+    put([32, sb]);
+    put([106]);
+    put([32, mx]);
+    put([106]);
+    put([33, sa]);
+    put([32, sd]);
+    put([32, sa]);
+    put([115]);
+    put([65, 16]);
+    put([120]);
+    put([33, sd]);
+    put([32, sc]);
+    put([32, sd]);
+    put([106]);
+    put([33, sc]);
+    put([32, sb]);
+    put([32, sc]);
+    put([115]);
+    put([65, 12]);
+    put([120]);
+    put([33, sb]);
+    put([32, sa]);
+    put([32, sb]);
+    put([106]);
+    put([32, my]);
+    put([106]);
+    put([33, sa]);
+    put([32, sd]);
+    put([32, sa]);
+    put([115]);
+    put([65, 8]);
+    put([120]);
+    put([33, sd]);
+    put([32, sc]);
+    put([32, sd]);
+    put([106]);
+    put([33, sc]);
+    put([32, sb]);
+    put([32, sc]);
+    put([115]);
+    put([65, 7]);
+    put([120]);
+    put([33, sb]);
+  }
+  let msgIdx = 0;
+  for (let round = 0; round < 7; round++) {
+    g(0, 4, 8, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(1, 5, 9, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(2, 6, 10, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(3, 7, 11, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(0, 5, 10, 15, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(1, 6, 11, 12, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(2, 7, 8, 13, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+    g(3, 4, 9, 14, MSG_ACCESS_ORDER[msgIdx], MSG_ACCESS_ORDER[msgIdx + 1]);
+    msgIdx += 2;
+  }
+  for (let i = 0; i < 8; i++) {
+    put([65, ...toLebU32Min2(CHUNK_CV_OFFSET + i * 4)]);
+    put([32, 16 + i]);
+    put([32, 24 + i]);
+    put([115]);
+    put([54, 2, 0]);
+  }
+  put([11]);
+  return code;
+}
+var wasmInstance = null;
+var wasmMemory = null;
+var wasmCompress4x = null;
+var wasmCompressChunks4x = null;
+var wasmCompressParent = null;
+var wasmMemoryView = null;
+var wasmMemoryView32 = null;
+function isSimdSupported() {
+  try {
+    const simdTest = new Uint8Array([
+      0,
+      97,
+      115,
+      109,
+      // magic: \0asm
+      1,
+      0,
+      0,
+      0,
+      // version: 1
+      // Type section (id=1): () -> v128
+      1,
+      // section id = 1 (type)
+      5,
+      // section length = 5
+      1,
+      // 1 type
+      96,
+      0,
+      1,
+      123,
+      // func () -> v128
+      // Function section (id=3)
+      3,
+      // section id = 3 (function)
+      2,
+      // section length = 2
+      1,
+      // 1 function
+      0,
+      // type index 0
+      // Code section (id=10) with v128.const
+      10,
+      // section id = 10 (code)
+      22,
+      // section length = 22
+      1,
+      // 1 function body
+      20,
+      // body length = 20
+      0,
+      // 0 locals
+      253,
+      12,
+      // v128.const opcode
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      11
+      // end
+    ]);
+    return WebAssembly.validate(simdTest);
+  } catch {
+    return false;
+  }
+}
+function setupArenaViews() {
+  if (!wasmMemory)
+    return;
+  const buffer = wasmMemory.buffer;
+  arenaCvStack = new Uint32Array(buffer, SIMD_MEMORY.CV_STACK, 64 * 8);
+  arenaParentBlock = new Uint32Array(buffer, SIMD_MEMORY.PARENT_BLOCK, 16);
+  arenaChunkCv = new Uint32Array(buffer, SIMD_MEMORY.CHUNK_CV, 8);
+  arenaTempCvs = new Uint32Array(buffer, SIMD_MEMORY.TEMP_CVS, 32);
+  arenaBatchBlockWords = new Uint32Array(buffer, SIMD_MEMORY.BATCH_BLOCK_WORDS, 16 * 16 * 4);
+  arenaBatchCv = new Uint32Array(buffer, SIMD_MEMORY.BATCH_CV, 32);
+  arenaBatchCounterLow = new Uint32Array(buffer, SIMD_MEMORY.BATCH_COUNTER_LOW, 4);
+  arenaBatchFlagsBase = new Uint32Array(buffer, SIMD_MEMORY.BATCH_FLAGS_BASE, 4);
+  arenaBatchOutput = new Uint32Array(buffer, SIMD_MEMORY.BATCH_OUTPUT, 32);
+}
+var cachedWasmBytes = null;
+function initSimdSync() {
+  if (wasmInstance)
+    return true;
+  if (!isSimdSupported()) {
+    return false;
+  }
+  try {
+    const wasmBytes = cachedWasmBytes || generateWasmBytes();
+    cachedWasmBytes = wasmBytes;
+    wasmMemory = new WebAssembly.Memory({ initial: 1 });
+    const importObject = {
+      js: { mem: wasmMemory }
+    };
+    const module = new WebAssembly.Module(wasmBytes.buffer);
+    wasmInstance = new WebAssembly.Instance(module, importObject);
+    wasmCompress4x = wasmInstance.exports.compress4x;
+    wasmCompressChunks4x = wasmInstance.exports.compressChunks4x;
+    wasmCompressParent = wasmInstance.exports.compressParent;
+    wasmMemoryView = new Uint8Array(wasmMemory.buffer);
+    wasmMemoryView32 = new Uint32Array(wasmMemory.buffer);
+    setupArenaViews();
+    return true;
+  } catch (e) {
+    console.warn("Failed to initialize WASM SIMD:", e);
+    return false;
+  }
+}
+var SIMD_MEMORY = {
+  // SIMD compress4x working area (used by WASM code) - single block
+  BLOCK_WORDS: 0,
+  // 4 x 16 words = 512 bytes (transposed layout)
+  CHAINING_VALUES: 512,
+  // 4 x 8 words = 128 bytes
+  OUTPUT: 640,
+  // 4 x 8 words = 128 bytes
+  COUNTER_LOW: 768,
+  // 4 words = 16 bytes
+  COUNTER_HIGH: 784,
+  // 4 words = 16 bytes
+  BLOCK_LEN: 800,
+  // 4 words = 16 bytes
+  FLAGS: 816,
+  // 4 words = 16 bytes
+  // End of single-block SIMD working area: 832 bytes
+  // SIMD compressChunks4x working area - 16 blocks batched
+  // Each block position has 16 v128 values (one per message word) = 256 bytes
+  // 16 block positions = 16 × 256 = 4096 bytes
+  BATCH_BLOCK_WORDS: 832,
+  // 16 positions × 256 bytes = 4096 bytes (transposed), ends at 4928
+  BATCH_CV: 4928,
+  // 4 × 8 words × 4 bytes = 128 bytes (working CVs), ends at 5056
+  BATCH_COUNTER_LOW: 5056,
+  // 4 words × 4 bytes = 16 bytes (per-chunk counters), ends at 5072
+  BATCH_FLAGS_BASE: 5072,
+  // 4 words × 4 bytes = 16 bytes (base flags, no START/END), ends at 5088
+  BATCH_OUTPUT: 5088,
+  // 4 × 8 words × 4 bytes = 128 bytes (final output), ends at 5216
+  // End of batch working area: 5216 bytes
+  // WASM Arena: JS working buffers (accessed via TypedArray views)
+  CV_STACK: 5216,
+  // 64 levels × 8 words × 4 bytes = 2048 bytes, ends at 7264
+  PARENT_BLOCK: 7264,
+  // 16 words × 4 bytes = 64 bytes, ends at 7328
+  CHUNK_CV: 7328,
+  // 8 words × 4 bytes = 32 bytes, ends at 7360
+  TEMP_CVS: 7360
+  // 4 × 8 words × 4 bytes = 128 bytes, ends at 7488
+  // Total arena usage: ~7488 bytes (fits comfortably in 64KB page)
+};
+var arenaCvStack = null;
+var arenaParentBlock = null;
+var arenaChunkCv = null;
+var arenaTempCvs = null;
+var arenaBatchBlockWords = null;
+var arenaBatchCv = null;
+var arenaBatchCounterLow = null;
+var arenaBatchFlagsBase = null;
+var arenaBatchOutput = null;
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/hash.js
+var CV_STACK_DEPTH = 64;
+var HYPER_CV_STACK = new Uint32Array(CV_STACK_DEPTH * 8);
+var CV_POOL_SIZE = 64;
+var CV_POOL = new Uint32Array(CV_POOL_SIZE * 8);
+var CV_VIEWS = [];
+for (let i = 0; i < CV_POOL_SIZE; i++) {
+  CV_VIEWS.push(CV_POOL.subarray(i * 8, i * 8 + 8));
+}
+var simdAvailable = false;
+var SIMD_THRESHOLD = 4 * CHUNK_LEN;
+function ensureSimdSync() {
+  if (simdAvailable)
+    return true;
+  simdAvailable = initSimdSync();
+  return simdAvailable;
+}
+var simdChunkCvs = new Uint32Array(32);
+var reusableTempCv = new Uint32Array(8);
+var reusableChunkCv = new Uint32Array(8);
+var reusablePureParentBlock = new Uint32Array(16);
+var reusablePureParentCv = new Uint32Array(8);
+var reusableSimdCvs = new Uint32Array(32);
+var reusableSimdParentBlock = new Uint32Array(16);
+var reusableSimdParentCv = new Uint32Array(8);
+var reusableOffsets = new Uint32Array(4);
+var reusableCounters = new Uint32Array(4);
+var reusableBlockLens = new Uint32Array(4);
+var reusableFlags = new Uint32Array(4);
+var reusableOut8 = new Uint32Array(8);
+var reusableOut8View = new Uint8Array(reusableOut8.buffer, 0, 32);
+var SIMD_CV_BASE = SIMD_MEMORY.CHAINING_VALUES / 4;
+var SIMD_OUT_BASE = SIMD_MEMORY.OUTPUT / 4;
+var SIMD_COUNTER_LOW_BASE = SIMD_MEMORY.COUNTER_LOW / 4;
+var SIMD_COUNTER_HIGH_BASE = SIMD_MEMORY.COUNTER_HIGH / 4;
+var SIMD_BLOCK_LEN_BASE = SIMD_MEMORY.BLOCK_LEN / 4;
+var BATCH_CV_BASE = SIMD_MEMORY.BATCH_CV / 4;
+var BATCH_COUNTER_LOW_BASE = SIMD_MEMORY.BATCH_COUNTER_LOW / 4;
+var BATCH_FLAGS_BASE_OFFSET = SIMD_MEMORY.BATCH_FLAGS_BASE / 4;
+var BATCH_OUTPUT_BASE = SIMD_MEMORY.BATCH_OUTPUT / 4;
+var batchChunkOffsets = new Uint32Array(4);
+var SIMD_FLAGS_BASE = SIMD_MEMORY.FLAGS / 4;
+function warmupSimd() {
+  return ensureSimdSync();
+}
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/blake3-jit/dist/esm/index.js
+if (typeof globalThis !== "undefined" && typeof globalThis.document !== "undefined") {
+  queueMicrotask(() => {
+    warmupSimd();
+  });
+}
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/xetchunk-wasm/dist/esm/xet-chunker.js
+var TARGET_CHUNK_SIZE = 64 * 1024;
+var BLAKE3_DATA_KEY = new Uint8Array([
+  102,
+  151,
+  245,
+  119,
+  91,
+  149,
+  80,
+  222,
+  49,
+  53,
+  203,
+  172,
+  165,
+  151,
+  24,
+  28,
+  157,
+  228,
+  33,
+  16,
+  155,
+  235,
+  43,
+  88,
+  180,
+  208,
+  176,
+  75,
+  147,
+  173,
+  242,
+  41
+]);
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/xetchunk-wasm/dist/esm/xorb-hash.js
+var BLAKE3_NODE_KEY = new Uint8Array([
+  1,
+  126,
+  197,
+  199,
+  165,
+  71,
+  41,
+  150,
+  253,
+  148,
+  102,
+  102,
+  180,
+  138,
+  2,
+  230,
+  93,
+  221,
+  83,
+  111,
+  55,
+  199,
+  109,
+  210,
+  248,
+  99,
+  82,
+  230,
+  74,
+  83,
+  113,
+  63
+]);
+var INDEX_OF_LAST_BYTE_OF_LAST_U64_IN_CHUNK_HASH = 3 * 8;
+var nodeHasher = Hasher.newKeyed(BLAKE3_NODE_KEY);
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/xetchunk-wasm/dist/esm/hash-utils.js
+var ZERO_KEY = new Uint8Array(32);
+var VERIFICATION_KEY = new Uint8Array([
+  127,
+  24,
+  87,
+  214,
+  206,
+  86,
+  237,
+  102,
+  18,
+  127,
+  249,
+  19,
+  231,
+  165,
+  195,
+  243,
+  164,
+  205,
+  38,
+  213,
+  181,
+  219,
+  73,
+  230,
+  65,
+  36,
+  152,
+  127,
+  40,
+  251,
+  148,
+  195
+]);
+var fileHasher = Hasher.newKeyed(ZERO_KEY);
+var verificationHasher = Hasher.newKeyed(VERIFICATION_KEY);
+
+// ../../../hf-oauth-build-pRp19k/node_modules/@huggingface/hub/dist/browser/index.mjs
+var HUB_URL = "https://huggingface.co";
+async function createApiError(response, opts) {
+  const error = new HubApiError(response.url, response.status, response.headers.get("X-Request-Id") ?? opts?.requestId);
+  error.message = `Api error with status ${error.statusCode}${opts?.message ? `. ${opts.message}` : ""}`;
+  const trailer = [`URL: ${error.url}`, error.requestId ? `Request ID: ${error.requestId}` : void 0].filter(Boolean).join(". ");
+  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+    const json = await response.json();
+    error.message = json.error || json.message || error.message;
+    if (json.error_description) {
+      error.message = error.message ? error.message + `: ${json.error_description}` : json.error_description;
+    }
+    error.data = json;
+  } else {
+    error.data = { message: await response.text() };
+  }
+  error.message += `. ${trailer}`;
+  throw error;
+}
+var HubApiError = class extends Error {
+  statusCode;
+  url;
+  requestId;
+  data;
+  constructor(url, statusCode, requestId, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.url = url;
+  }
+};
+var isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isWebWorker = typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope";
+var isBackend = !isBrowser && !isWebWorker;
+var isFrontend = !isBackend;
+var resolve;
+var waitPromise = new Promise((r) => {
+  resolve = r;
+});
+function base64FromBytes(arr) {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin = [];
+    arr.forEach((byte) => {
+      bin.push(String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+var hashSize = 1 << 16;
+var mlBits = 4;
+var mlMask = (1 << mlBits) - 1;
+var runBits = 4;
+var runMask = (1 << runBits) - 1;
+var blockBuf = makeBuffer(5 << 20);
+var hashTable = makeHashTable();
+function makeHashTable() {
+  try {
+    return new Uint32Array(hashSize);
+  } catch (error) {
+    const hashTable2 = new Array(hashSize);
+    for (let i = 0; i < hashSize; i++) {
+      hashTable2[i] = 0;
+    }
+    return hashTable2;
+  }
+}
+function makeBuffer(size) {
+  return new Uint8Array(size);
+}
+var textEncoder = new TextEncoder();
+var CRLF = textEncoder.encode("\r\n");
+var HEADER_SEPARATOR = textEncoder.encode("\r\n\r\n");
+function hasH2Fetch(versions = typeof process !== "undefined" ? process.versions : void 0, frontend = isFrontend) {
+  if (frontend || !versions?.undici || versions.bun) {
+    return false;
+  }
+  return Number(versions.undici.split(".")[0]) >= 8;
+}
+var GLOBAL_DISPATCHER_KEYS = [/* @__PURE__ */ Symbol.for("undici.globalDispatcher.2"), /* @__PURE__ */ Symbol.for("undici.globalDispatcher.1")];
+function withHttp1(base) {
+  return {
+    dispatch: (options, handler) => base.dispatch({ ...options, allowH2: false }, handler)
+  };
+}
+var cached;
+async function getHttp1Dispatcher() {
+  const globals = globalThis;
+  const find = () => GLOBAL_DISPATCHER_KEYS.map((key) => globals[key]).find((d) => typeof d?.dispatch === "function");
+  let base = find();
+  if (base === void 0) {
+    await (await fetch("data:,")).arrayBuffer();
+    base = find();
+  }
+  if (base === void 0) {
+    return void 0;
+  }
+  if (cached?.base !== base) {
+    cached = { base, http1: withHttp1(base) };
+  }
+  return cached.http1;
+}
+var undiciHttp1Fetch = async (input, init) => {
+  const dispatcher = await getHttp1Dispatcher();
+  return dispatcher ? fetch(input, { ...init, dispatcher }) : fetch(input, init);
+};
+var http1Fetch = hasH2Fetch() ? undiciHttp1Fetch : (input, init) => fetch(input, init);
+var PARALLEL_MIN_IN_FLIGHT_BYTES = 64 * 1024 * 1024;
+var PARALLEL_MAX_IN_FLIGHT_BYTES = 256 * 1024 * 1024;
+var HASH_LENGTH = 32;
+var XORB_HASH_BOOKEND = "ff".repeat(HASH_LENGTH);
+var ZERO_KEY2 = new Uint8Array(32);
+var TARGET_CHUNK_SIZE2 = 64 * 1024;
+var MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE2;
+var XORB_SIZE = 64 * 1024 * 1024;
+var MAX_XORB_CHUNKS = 8 * 1024;
+var PROCESSING_PROGRESS_RATIO = 0.1;
+var UPLOADING_PROGRESS_RATIO = 1 - PROCESSING_PROGRESS_RATIO;
+var SHARD_MAX_SIZE = 64 * 1024 * 1024;
+var SHARD_MAGIC_TAG = new Uint8Array([
+  "H".charCodeAt(0),
+  "F".charCodeAt(0),
+  "R".charCodeAt(0),
+  "e".charCodeAt(0),
+  "p".charCodeAt(0),
+  "o".charCodeAt(0),
+  "M".charCodeAt(0),
+  "e".charCodeAt(0),
+  "t".charCodeAt(0),
+  "a".charCodeAt(0),
+  "D".charCodeAt(0),
+  "a".charCodeAt(0),
+  "t".charCodeAt(0),
+  "a".charCodeAt(0),
+  0,
+  85,
+  105,
+  103,
+  69,
+  106,
+  123,
+  129,
+  87,
+  131,
+  165,
+  189,
+  217,
+  92,
+  205,
+  209,
+  74,
+  169
+]);
+async function oauthHandleRedirect(opts) {
+  if (typeof window === "undefined" && !opts?.redirectedUrl) {
+    throw new Error("oauthHandleRedirect is only available in the browser, unless you provide redirectedUrl");
+  }
+  if (typeof localStorage === "undefined" && (!opts?.nonce || !opts?.codeVerifier)) {
+    throw new Error(
+      "oauthHandleRedirect requires localStorage to be available, unless you provide nonce and codeVerifier"
+    );
+  }
+  const redirectedUrl = opts?.redirectedUrl ?? window.location.href;
+  const searchParams = (() => {
+    try {
+      return new URL(redirectedUrl).searchParams;
+    } catch (err) {
+      throw new Error("Failed to parse redirected URL: " + redirectedUrl);
+    }
+  })();
+  const [error, errorDescription] = [searchParams.get("error"), searchParams.get("error_description")];
+  if (error) {
+    throw new Error(`${error}: ${errorDescription}`);
+  }
+  const code = searchParams.get("code");
+  const nonce = opts?.nonce ?? localStorage.getItem("huggingface.co:oauth:nonce");
+  if (!code) {
+    throw new Error("Missing oauth code from query parameters in redirected URL: " + redirectedUrl);
+  }
+  if (!nonce) {
+    throw new Error("Missing oauth nonce from localStorage");
+  }
+  const codeVerifier = opts?.codeVerifier ?? localStorage.getItem("huggingface.co:oauth:code_verifier");
+  if (!codeVerifier) {
+    throw new Error("Missing oauth code_verifier from localStorage");
+  }
+  const state = searchParams.get("state");
+  if (!state) {
+    throw new Error("Missing oauth state from query parameters in redirected URL");
+  }
+  let parsedState;
+  try {
+    parsedState = JSON.parse(state);
+  } catch {
+    throw new Error("Invalid oauth state in redirected URL, unable to parse JSON: " + state);
+  }
+  if (parsedState.nonce !== nonce) {
+    throw new Error("Invalid oauth state in redirected URL");
+  }
+  const hubUrl = opts?.hubUrl || HUB_URL;
+  const openidConfigUrl = `${new URL(hubUrl).origin}/.well-known/openid-configuration`;
+  const openidConfigRes = await fetch(openidConfigUrl, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!openidConfigRes.ok) {
+    throw await createApiError(openidConfigRes);
+  }
+  const openidConfig = await openidConfigRes.json();
+  const tokenRes = await fetch(openidConfig.token_endpoint, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: parsedState.redirectUri,
+      code_verifier: codeVerifier
+    }).toString()
+  });
+  if (!opts?.codeVerifier) {
+    localStorage.removeItem("huggingface.co:oauth:code_verifier");
+  }
+  if (!opts?.nonce) {
+    localStorage.removeItem("huggingface.co:oauth:nonce");
+  }
+  if (!tokenRes.ok) {
+    throw await createApiError(tokenRes);
+  }
+  const token = await tokenRes.json();
+  const accessTokenExpiresAt = new Date(Date.now() + token.expires_in * 1e3);
+  const userInfoRes = await fetch(openidConfig.userinfo_endpoint, {
+    headers: {
+      Authorization: `Bearer ${token.access_token}`
+    }
+  });
+  if (!userInfoRes.ok) {
+    throw await createApiError(userInfoRes);
+  }
+  const userInfo = await userInfoRes.json();
+  return {
+    accessToken: token.access_token,
+    accessTokenExpiresAt,
+    userInfo,
+    state: parsedState.state,
+    scope: token.scope
+  };
+}
+async function oauthLoginUrl(opts) {
+  if (typeof window === "undefined" && (!opts?.redirectUrl || !opts?.clientId)) {
+    throw new Error("oauthLogin is only available in the browser, unless you provide clientId and redirectUrl");
+  }
+  if (typeof localStorage === "undefined" && !opts?.localStorage) {
+    throw new Error(
+      "oauthLogin requires localStorage to be available in the context, unless you provide a localStorage empty object as argument"
+    );
+  }
+  const hubUrl = opts?.hubUrl || HUB_URL;
+  const openidConfigUrl = `${new URL(hubUrl).origin}/.well-known/openid-configuration`;
+  const openidConfigRes = await fetch(openidConfigUrl, {
+    headers: {
+      Accept: "application/json"
+    }
+  });
+  if (!openidConfigRes.ok) {
+    throw await createApiError(openidConfigRes);
+  }
+  const opendidConfig = await openidConfigRes.json();
+  const newNonce = globalThis.crypto.randomUUID();
+  const newCodeVerifier = globalThis.crypto.randomUUID() + globalThis.crypto.randomUUID();
+  if (opts?.localStorage) {
+    if (opts.localStorage.codeVerifier !== void 0 && opts.localStorage.codeVerifier !== null) {
+      throw new Error(
+        "localStorage.codeVerifier must be initially set to null or undefined, and will be filled by oauthLoginUrl"
+      );
+    }
+    if (opts.localStorage.nonce !== void 0 && opts.localStorage.nonce !== null) {
+      throw new Error(
+        "localStorage.nonce must be initially set to null or undefined, and will be filled by oauthLoginUrl"
+      );
+    }
+    opts.localStorage.codeVerifier = newCodeVerifier;
+    opts.localStorage.nonce = newNonce;
+  } else {
+    localStorage.setItem("huggingface.co:oauth:nonce", newNonce);
+    localStorage.setItem("huggingface.co:oauth:code_verifier", newCodeVerifier);
+  }
+  const redirectUri = opts?.redirectUrl || (typeof window !== "undefined" ? window.location.href : void 0);
+  if (!redirectUri) {
+    throw new Error("Missing redirectUrl");
+  }
+  const state = JSON.stringify({
+    nonce: newNonce,
+    redirectUri,
+    state: opts?.state
+  });
+  const variables = (
+    // @ts-expect-error window.huggingface is defined inside static Spaces.
+    typeof window !== "undefined" ? window.huggingface?.variables ?? null : null
+  );
+  const clientId = opts?.clientId || variables?.OAUTH_CLIENT_ID;
+  if (!clientId) {
+    if (variables) {
+      throw new Error("Missing clientId, please add hf_oauth: true to the README.md's metadata in your static Space");
+    }
+    throw new Error("Missing clientId");
+  }
+  const challenge = base64FromBytes(
+    new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(newCodeVerifier)))
+  ).replace(/[+]/g, "-").replace(/[/]/g, "_").replace(/=/g, "");
+  return `${opendidConfig.authorization_endpoint}?${new URLSearchParams({
+    client_id: clientId,
+    scope: opts?.scopes || variables?.OAUTH_SCOPES || "openid profile",
+    response_type: "code",
+    redirect_uri: redirectUri,
+    state,
+    code_challenge: challenge,
+    code_challenge_method: "S256"
+  }).toString()}`;
+}
+var DIFFUSERS_SAFETENSORS_FILE = "diffusion_pytorch_model.safetensors";
+var DIFFUSERS_SAFETENSORS_INDEX_FILE = "diffusion_pytorch_model.safetensors.index.json";
+var DIFFUSERS_WEIGHTS_SUBFOLDERS = ["transformer", "unet"];
+var MAX_TENSOR_DIM = 2 ** 32;
+var LIBRARY_WEIGHT_CANDIDATES = {
+  // diffusers keeps the main module (the diffusion transformer / U-Net) under a subfolder,
+  // or at the repo root for single-component repos (ControlNets, standalone VAEs). This matches
+  // how a diffusion model's size is conventionally reported: the diffusion transformer / U-Net,
+  // not the sum of VAE + text encoders.
+  diffusers: [
+    ...DIFFUSERS_WEIGHTS_SUBFOLDERS.map((folder) => ({
+      single: `${folder}/${DIFFUSERS_SAFETENSORS_FILE}`,
+      index: `${folder}/${DIFFUSERS_SAFETENSORS_INDEX_FILE}`
+    })),
+    { single: DIFFUSERS_SAFETENSORS_FILE, index: DIFFUSERS_SAFETENSORS_INDEX_FILE }
+  ]
+};
+export {
+  oauthHandleRedirect,
+  oauthLoginUrl
+};

vendor/hf-oauth/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@huggingface/hub",
+  "version": "2.17.6",
+  "description": "Utilities to interact with the Hugging Face hub",
+  "keywords": [
+    "api",
+    "client",
+    "face",
+    "hub",
+    "hugging",
+    "huggingface"
+  ],
+  "license": "MIT",
+  "author": "Hugging Face",
+  "repository": "https://github.com/huggingface/huggingface.js.git",
+  "bin": {
+    "hfjs": "./dist/cli.js"
+  },
+  "source": "index.ts",
+  "files": [
+    "dist",
+    "index.ts",
+    "src",
+    "tsconfig.json"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "browser": {
+    "./src/utils/sha256-node.ts": false,
+    "./src/utils/sub-paths.ts": false,
+    "./src/utils/FileBlob.ts": false,
+    "./src/lib/cache-management.ts": false,
+    "./src/lib/download-file-to-cache-dir.ts": false,
+    "./src/lib/snapshot-download.ts": false,
+    "./dist/index.js": "./dist/browser/index.js",
+    "./dist/index.mjs": "./dist/browser/index.mjs"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@huggingface/xetchunk-wasm": "^0.2.0",
+    "@huggingface/tasks": "^0.21.58"
+  },
+  "devDependencies": {
+    "@types/cli-progress": "^3.11.6"
+  },
+  "optionalDependencies": {
+    "cli-progress": "^3.12.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "lint": "eslint --quiet --fix --ext .cjs,.ts .",
+    "lint:check": "eslint --ext .cjs,.ts .",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "build": "tsup && tsc --emitDeclarationOnly --declaration",
+    "test": "vitest run",
+    "test:browser": "vitest run --browser.name=chrome --browser.headless --config vitest-browser.config.mts",
+    "check": "tsc",
+    "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler --clean",
+    "bench": "tsx scripts/bench.ts",
+    "debug-xet": "tsx scripts/debug-xet.ts"
+  }
+}