@chttp/auth 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Joaquin Terrasa & contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,92 @@
-# Temporary Holding Version
+# @chttp/auth
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Auth primitives for chttp apps — sessions (Lucia pattern), cookies, scrypt passwords, double-submit CSRF, HS256 JWT, OAuth2 authorization-code + PKCE, and TOTP — as plain async functions over `node:crypto`, authored in the scriptc-compilable subset. The same source builds to a JS package with `tsc` and lowers into a native ELF with `scriptc build`. Zero runtime dependencies.
+
+Every function is string-in/string-out or boolean-out; none of them touches a request object — compose them inside `@chttp/router` handlers yourself.
+
+## Quickstart
+
+```ts
+import {
+  MemorySessionStore,
+  buildSessionCookie,
+  createSession,
+  generateSessionToken,
+  readCookie,
+  validateSessionToken,
+} from "@chttp/auth";
+
+const store = new MemorySessionStore(); // dev/test only — see below
+
+app.post("/login", async (c) => {
+  const token = generateSessionToken();
+  await createSession(store, token, "user-1", { role: "admin" });
+  c.header("set-cookie", buildSessionCookie(token, { secure: false }));
+  return c.status(201).text("ok");
+});
+
+app.get("/me", async (c) => {
+  const tok = readCookie(c.req.header("cookie"), "session");
+  const rec = tok === null ? null : await validateSessionToken(store, tok);
+  if (rec === null) return c.status(401).text("unauthorized");
+  return c.text("user:" + rec.userId);
+});
+```
+
+## What it does
+
+- **Sessions** — `generateSessionToken` (384-bit `id.secret` bearer token), `hashToken` (SHA-256 store key — the only thing persisted), `createSession`, `validateSessionToken` (sliding expiry: extends past `extensionThresholdSeconds`, deletes on expiry), `invalidateSession`, `invalidateAllUserSessions`. The `SessionStore` contract is sync-or-async: stores may return values or Promises; auth `await`s either way. `MemorySessionStore` ships for dev/test — **NOT for production** (process memory loses sessions on restart and shares nothing across replicas).
+- **Cookies** — `serializeCookie`/`readCookie` plus prebuilt `buildSessionCookie` (HttpOnly, SameSite=Lax, Secure, Max-Age bound to TTL), `buildExpiredSessionCookie` (logout), `buildCsrfCookie` (deliberately not HttpOnly — double-submit needs a JS read).
+- **Passwords** — `hashPassword`/`verifyPassword`, self-describing `scrypt:N:r:p:salt:hash` format, OWASP defaults (N=2^17, r=8, p=1, 64-byte key). Verify is timing-safe and dummy-hashes on malformed rows.
+- **CSRF** — `generateCsrfToken`, `verifyCsrfToken` (constant-time double-submit compare), `verifyRequestOrigin` (Origin allowlist).
+- **JWT** — `signJwt`/`verifyJwt`/`verifyJwtWith`, JWS compact only, HS256. Verify is null-on-invalid for every failure: bad format, wrong alg (`none` hard-rejected), bad signature, expired/nbf, issuer/audience mismatch. `verifyJwtWith` parses claims through any Standard Schema validator (`@chttp/val`, valibot, zod).
+- **OAuth2 + PKCE** — `generateState`, `generateCodeVerifier`, `codeChallenge` (S256), `createAuthorizationURL`, `exchangeCodeForTokens` (form POST + basic auth, JSON or urlencoded responses), `fetchUserInfo`/`fetchUserInfoWith`. `googleProvider`, `githubProvider`, `discordProvider` presets are plain records — a new provider is a 15-LoC record in your code.
+- **TOTP** — `generateTotpSecret` (base32), `totpAuthUri` (otpauth:// enrollment URI), `verifyTotp` (HMAC-SHA1, 6 digits, 30 s step, ±1 window, constant-time compare).
+
+## Recipe: API keys
+
+No dedicated module is needed — an API key is a session token whose record carries scopes and a far-future expiry. Only the SHA-256 hash is ever stored, so a database leak doesn't leak usable keys.
+
+```ts
+import {
+  createSession,
+  generateSessionToken,
+  hashToken,
+  invalidateSession,
+  validateSessionToken,
+} from "@chttp/auth";
+
+// Provisioning: show `apiKey` to the caller exactly once.
+const TEN_YEARS = 10 * 365 * 24 * 60 * 60;
+const apiKey = generateSessionToken(); // id.secret bearer token (~64 chars)
+await createSession(store, apiKey, ownerUserId, { scopes: ["read", "deploy"] }, {
+  ttlSeconds: TEN_YEARS,
+});
+
+// Per request: "Authorization: Bearer <apiKey>". extensionThresholdSeconds: 0
+// keeps the record's expiry fixed — API keys shouldn't slide on every call.
+const key = bearer(c.req.header("authorization"));
+const rec =
+  key === null
+    ? null
+    : await validateSessionToken(store, key, { extensionThresholdSeconds: 0 });
+if (rec === null) return c.status(401).text("unauthorized");
+const scopes = rec.attributes.scopes as string[];
+if (scopes.indexOf("deploy") < 0) return c.status(403).text("forbidden");
+
+// Revocation is the same as sessions:
+await invalidateSession(store, leakedKey);
+```
+
+Use `store.get(hashToken(key))` directly instead of `validateSessionToken` when you want to skip the expiry check entirely and manage revocation/rotation yourself; stamp `lastUsedAt` into `rec.attributes` on a throttle if you need audit fields.
+
+## Notes
+
+- **ES256 is not available in this build.** scriptc 0.3.3's static `node:crypto` slice covers hashing, randomness and secret KeyObjects — `createSign`/`createVerify` have no lowering, so `signJwt({ alg: "ES256" })` throws `E_BAD_ALG` and `verifyJwt` rejects ES256 tokens with null. The `string | KeyObject` signature is kept so the feature slots in upstream without a breaking change.
+- **Verify paths never throw** — `null`/`false` on any invalid input (attacker-controlled). Sign and exchange throw `E_*` code strings only on caller bugs (missing key, bad alg, non-positive TTL).
+- **`validateSessionToken` costs one microtask on sync stores** — the await-everything seam keeps postgres/redis adapters possible without forking the API; the SHA-256 dominates the cost anyway.
+- **Refresh-token storage/rotation is app logic.** `exchangeCodeForTokens` returns the `TokenSet`; persist it alongside the session (and re-exchange when `expires_in` elapses) in your own store.
+
+## Docs
+
+Package page: [`docs/auth.md`](https://github.com/sigilco/cutils/tree/main/docs/auth.md) on the docs site. Contributor/subset notes: [`AGENTS.md`](./AGENTS.md) (subset bans + the release security checklist).

package/dist/esm/cookie.d.ts

@@ -0,0 +1,18 @@
+export interface CookieAttrs {
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: "lax" | "strict" | "none";
+}
+export declare const SESSION_COOKIE_NAME = "session";
+export declare const CSRF_COOKIE_NAME = "csrf";
+export declare function serializeCookie(name: string, value: string, attrs: CookieAttrs): string;
+export declare function readCookie(cookieHeader: string | null, name: string): string | null;
+export interface SessionCookieOpts {
+    secure?: boolean;
+    ttlSeconds?: number;
+}
+export declare function buildSessionCookie(token: string, opts?: SessionCookieOpts): string;
+export declare function buildExpiredSessionCookie(opts?: SessionCookieOpts): string;
+export declare function buildCsrfCookie(token: string, opts?: SessionCookieOpts): string;

package/dist/esm/cookie.js

@@ -0,0 +1,88 @@
+// Set-Cookie serialization + minimal Cookie-header read. Three cookies are
+// set (session, expired-session, csrf) and one is read (session) — 80 LoC
+// beats a jar dependency.
+export const SESSION_COOKIE_NAME = "session";
+export const CSRF_COOKIE_NAME = "csrf";
+function sameSiteAttr(v) {
+    if (v === "strict") {
+        return "Strict";
+    }
+    if (v === "none") {
+        return "None";
+    }
+    return "Lax";
+}
+// Full Set-Cookie header value.
+export function serializeCookie(name, value, attrs) {
+    let out = name + "=" + value;
+    const path = attrs.path === undefined ? "/" : attrs.path;
+    out += "; Path=" + path;
+    if (attrs.maxAge !== undefined) {
+        out += "; Max-Age=" + Math.floor(attrs.maxAge);
+    }
+    if (attrs.httpOnly === true) {
+        out += "; HttpOnly";
+    }
+    if (attrs.secure === true) {
+        out += "; Secure";
+    }
+    if (attrs.sameSite !== undefined) {
+        out += "; SameSite=" + sameSiteAttr(attrs.sameSite);
+    }
+    return out;
+}
+// Minimal read of the Cookie request header: returns the raw value for
+// `name`, or null. First match wins; values are returned undecoded (the
+// session/csrf tokens this package sets are base64url, which needs none).
+export function readCookie(cookieHeader, name) {
+    if (cookieHeader === null) {
+        return null;
+    }
+    const prefix = name + "=";
+    const parts = cookieHeader.split(";");
+    for (let i = 0; i < parts.length; i++) {
+        const p = parts[i].trim();
+        if (p.startsWith(prefix)) {
+            return p.slice(prefix.length);
+        }
+    }
+    return null;
+}
+const DEFAULT_COOKIE_TTL = 30 * 24 * 60 * 60;
+// Prebuilt session cookie: HttpOnly, SameSite=Lax, Path=/, Secure=true
+// (override for localhost), Max-Age bound to the session TTL.
+export function buildSessionCookie(token, opts) {
+    const secure = opts === undefined || opts.secure === undefined ? true : opts.secure;
+    const ttl = opts === undefined || opts.ttlSeconds === undefined ? DEFAULT_COOKIE_TTL : opts.ttlSeconds;
+    return serializeCookie(SESSION_COOKIE_NAME, token, {
+        maxAge: ttl,
+        path: "/",
+        secure: secure,
+        httpOnly: true,
+        sameSite: "lax",
+    });
+}
+// Logout: same name, empty value, already expired.
+export function buildExpiredSessionCookie(opts) {
+    const secure = opts === undefined || opts.secure === undefined ? true : opts.secure;
+    return serializeCookie(SESSION_COOKIE_NAME, "", {
+        maxAge: 0,
+        path: "/",
+        secure: secure,
+        httpOnly: true,
+        sameSite: "lax",
+    });
+}
+// CSRF double-submit cookie: deliberately NOT HttpOnly — the pattern needs
+// JS (or the page itself) to read the token into a form field/header.
+export function buildCsrfCookie(token, opts) {
+    const secure = opts === undefined || opts.secure === undefined ? true : opts.secure;
+    const ttl = opts === undefined || opts.ttlSeconds === undefined ? DEFAULT_COOKIE_TTL : opts.ttlSeconds;
+    return serializeCookie(CSRF_COOKIE_NAME, token, {
+        maxAge: ttl,
+        path: "/",
+        secure: secure,
+        httpOnly: false,
+        sameSite: "lax",
+    });
+}

package/dist/esm/csrf.d.ts

@@ -0,0 +1,3 @@
+export declare function generateCsrfToken(): string;
+export declare function verifyCsrfToken(cookieToken: string | null, submittedToken: string | null): boolean;
+export declare function verifyRequestOrigin(originHeader: string | null, allowedOrigins: string[]): boolean;

package/dist/esm/csrf.js

@@ -0,0 +1,36 @@
+// CSRF: double-submit cookie + Origin allowlist — the two halves of the
+// pattern. The token compare is constant-time (length pre-check, then
+// timingSafeEqual); the origin allowlist is a plain string match — Origin
+// is not secret material.
+import { randomBytes, timingSafeEqual } from "node:crypto";
+// base64url(32 random bytes).
+export function generateCsrfToken() {
+    return randomBytes(32).toString("base64url");
+}
+// Double-submit: the cookie token and the submitted (form field / header)
+// token must match byte-for-byte under a constant-time compare.
+export function verifyCsrfToken(cookieToken, submittedToken) {
+    if (cookieToken === null || submittedToken === null) {
+        return false;
+    }
+    const a = Buffer.from(cookieToken, "utf8");
+    const b = Buffer.from(submittedToken, "utf8");
+    // timingSafeEqual throws on length mismatch — length pre-check.
+    if (a.length !== b.length) {
+        return false;
+    }
+    return timingSafeEqual(a, b);
+}
+// Origin check for state-changing requests (the other CSRF half): the
+// request's Origin header must appear verbatim in the allowlist.
+export function verifyRequestOrigin(originHeader, allowedOrigins) {
+    if (originHeader === null) {
+        return false;
+    }
+    for (let i = 0; i < allowedOrigins.length; i++) {
+        if (allowedOrigins[i] === originHeader) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist/esm/encoding.d.ts

@@ -0,0 +1,5 @@
+export declare function toHex(bytes: Uint8Array): string;
+export declare function b64urlEncode(bytes: Uint8Array): string;
+export declare function b64urlDecode(text: string): Buffer;
+export declare function base32Encode(bytes: Uint8Array): string;
+export declare function base32Decode(text: string): Uint8Array | null;

package/dist/esm/encoding.js

@@ -0,0 +1,71 @@
+// Byte <-> text helpers shared across the auth primitives.
+//
+// - Hex goes through a lookup table: `number.toString(16)` is SC2012-fenced
+//   under scriptc (probe finding from the hono/jwt attempt), and
+//   `Buffer.toString("hex")` on variable digests is avoided for the same
+//   class of reason — the table is deterministic.
+// - base64url goes through Buffer (`Buffer.from(bytes).toString("base64url")`
+//   — probe-verified static in scriptc 0.3.3). Output is unpadded, which is
+//   what session tokens, PKCE challenges and JWS all require.
+// - base32 is a 40-LoC RFC 4648 hand-roll (standard alphabet, no padding on
+//   encode, padding/lowercase tolerated on decode). It exists only for TOTP.
+const HEX_DIGITS = "0123456789abcdef";
+export function toHex(bytes) {
+    let out = "";
+    for (let i = 0; i < bytes.length; i++) {
+        const b = bytes[i];
+        out += HEX_DIGITS[b >>> 4] + HEX_DIGITS[b & 15];
+    }
+    return out;
+}
+export function b64urlEncode(bytes) {
+    return Buffer.from(bytes).toString("base64url");
+}
+export function b64urlDecode(text) {
+    return Buffer.from(text, "base64url");
+}
+const B32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+// RFC 4648 base32, no padding emitted (otpauth secrets are unpadded).
+export function base32Encode(bytes) {
+    let out = "";
+    let bits = 0;
+    let value = 0;
+    for (let i = 0; i < bytes.length; i++) {
+        value = (value << 8) | bytes[i];
+        bits += 8;
+        while (bits >= 5) {
+            out += B32_ALPHABET[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0) {
+        out += B32_ALPHABET[(value << (5 - bits)) & 31];
+    }
+    return out;
+}
+// Tolerates `=` padding and lowercase input; returns null on any character
+// outside the RFC 4648 alphabet (null-on-invalid — this is attacker input
+// when it comes from a stored secret or a user-typed key).
+export function base32Decode(text) {
+    const upper = text.toUpperCase();
+    let bits = 0;
+    let value = 0;
+    const out = [];
+    for (let i = 0; i < upper.length; i++) {
+        const ch = upper[i];
+        if (ch === "=") {
+            break;
+        }
+        const idx = B32_ALPHABET.indexOf(ch);
+        if (idx < 0) {
+            return null;
+        }
+        value = (value << 5) | idx;
+        bits += 5;
+        if (bits >= 8) {
+            out.push((value >>> (bits - 8)) & 255);
+            bits -= 8;
+        }
+    }
+    return new Uint8Array(out);
+}

package/dist/esm/errors.d.ts

@@ -0,0 +1 @@
+export declare function authError(code: string, detail: string): Error;

package/dist/esm/errors.js

@@ -0,0 +1,7 @@
+// Code-string errors for caller bugs on the sign/exchange paths. Verify
+// paths never throw — they return null/false — so these codes only fire for
+// programmer error: missing key material, an alg the package does not sign,
+// or malformed parameters.
+export function authError(code, detail) {
+    return new Error(code + ": " + detail);
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,19 @@
+export { generateSessionToken, hashToken, createSession, validateSessionToken, invalidateSession, invalidateAllUserSessions, } from "./session.ts";
+export type { SessionRecord, SessionRecordData, SessionStore, SessionStoreCore, SessionOpts, } from "./session.ts";
+export { MemorySessionStore, MemorySessionStoreCore } from "./memory-store.ts";
+export { serializeCookie, readCookie, buildSessionCookie, buildExpiredSessionCookie, buildCsrfCookie, SESSION_COOKIE_NAME, CSRF_COOKIE_NAME, } from "./cookie.ts";
+export type { CookieAttrs, SessionCookieOpts } from "./cookie.ts";
+export { hashPassword, verifyPassword } from "./password.ts";
+export type { PasswordOpts } from "./password.ts";
+export { generateCsrfToken, verifyCsrfToken, verifyRequestOrigin } from "./csrf.ts";
+export { signJwt, verifyJwt, verifyJwtWith } from "./jwt.ts";
+export type { SignJwtOpts, VerifyJwtOpts } from "./jwt.ts";
+export { generateState, generateCodeVerifier, codeChallenge, createAuthorizationURL, exchangeCodeForTokens, fetchUserInfo, fetchUserInfoWith, } from "./oauth.ts";
+export type { OAuthProvider, TokenSet, AuthorizeParams, ExchangeParams } from "./oauth.ts";
+export { googleProvider, githubProvider, discordProvider } from "./providers.ts";
+export { generateTotpSecret, totpAuthUri, verifyTotp } from "./totp.ts";
+export type { TotpUriOpts, VerifyTotpOpts } from "./totp.ts";
+export { base32Encode, base32Decode, toHex, b64urlEncode, b64urlDecode } from "./encoding.ts";
+export { authError } from "./errors.ts";
+export { runSchema } from "./types.ts";
+export type { StandardSchemaV1, InferOutput } from "./types.ts";

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+// @chttp/auth — public surface. Plain async functions over node:crypto:
+// sessions (Lucia pattern), cookies, scrypt passwords, double-submit CSRF,
+// HS256/ES256 JWT, OAuth2 authorization-code + PKCE, TOTP. Zero runtime
+// dependencies; the schema seam is a local StandardSchemaV1 twin.
+export { generateSessionToken, hashToken, createSession, validateSessionToken, invalidateSession, invalidateAllUserSessions, } from "./session.js";
+export { MemorySessionStore, MemorySessionStoreCore } from "./memory-store.js";
+export { serializeCookie, readCookie, buildSessionCookie, buildExpiredSessionCookie, buildCsrfCookie, SESSION_COOKIE_NAME, CSRF_COOKIE_NAME, } from "./cookie.js";
+export { hashPassword, verifyPassword } from "./password.js";
+export { generateCsrfToken, verifyCsrfToken, verifyRequestOrigin } from "./csrf.js";
+export { signJwt, verifyJwt, verifyJwtWith } from "./jwt.js";
+export { generateState, generateCodeVerifier, codeChallenge, createAuthorizationURL, exchangeCodeForTokens, fetchUserInfo, fetchUserInfoWith, } from "./oauth.js";
+export { googleProvider, githubProvider, discordProvider } from "./providers.js";
+export { generateTotpSecret, totpAuthUri, verifyTotp } from "./totp.js";
+export { base32Encode, base32Decode, toHex, b64urlEncode, b64urlDecode } from "./encoding.js";
+export { authError } from "./errors.js";
+export { runSchema } from "./types.js";

package/dist/esm/jwt.d.ts

@@ -0,0 +1,21 @@
+import type { KeyObject } from "node:crypto";
+import type { StandardSchemaV1 } from "./types.ts";
+export interface SignJwtOpts {
+    alg?: "HS256" | "ES256";
+    expiresInSeconds?: number;
+    issuer?: string;
+    audience?: string;
+}
+export interface VerifyJwtOpts {
+    alg?: "HS256" | "ES256";
+    issuer?: string;
+    audience?: string;
+    clockToleranceSeconds?: number;
+}
+export declare function signJwt(payload: {
+    [k: string]: unknown;
+}, key: string | KeyObject, opts?: SignJwtOpts): string;
+export declare function verifyJwt(token: string, key: string | KeyObject, opts?: VerifyJwtOpts): {
+    [k: string]: unknown;
+} | null;
+export declare function verifyJwtWith<Schema extends StandardSchemaV1>(token: string, key: string | KeyObject, schema: Schema, opts?: VerifyJwtOpts): Promise<StandardSchemaV1.InferOutput<Schema> | null>;