@spfn/auth 0.2.0-beta.84 → 0.2.0-beta.85

package/dist/client-proof.js

@@ -0,0 +1,1225 @@
+// src/server/client-proof/canonical-json.ts
+var CanonicalJsonError = class extends Error {
+  constructor(code) {
+    super(`canonical JSON: ${code}`);
+    this.code = code;
+    this.name = "CanonicalJsonError";
+  }
+};
+var INT64_MIN = -(2n ** 63n);
+var INT64_MAX = 2n ** 63n - 1n;
+function parseCanonicalJson(bytes) {
+  let text2;
+  try {
+    text2 = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    throw new CanonicalJsonError("INVALID_UTF8");
+  }
+  const parser = new Parser(text2);
+  const value = parser.parseValue();
+  parser.skipWhitespace();
+  if (!parser.atEnd()) {
+    throw new CanonicalJsonError("TRAILING_CONTENT");
+  }
+  return value;
+}
+function isCanonicalBytes(bytes, value) {
+  const encoded = encodeCanonicalJson(value);
+  if (encoded.length !== bytes.length) {
+    return false;
+  }
+  for (let i = 0; i < encoded.length; i++) {
+    if (encoded[i] !== bytes[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+var Parser = class {
+  constructor(text2) {
+    this.text = text2;
+  }
+  pos = 0;
+  atEnd() {
+    return this.pos >= this.text.length;
+  }
+  skipWhitespace() {
+    while (!this.atEnd()) {
+      const c = this.text[this.pos];
+      if (c === " " || c === "	" || c === "\n" || c === "\r") {
+        this.pos++;
+        continue;
+      }
+      break;
+    }
+  }
+  parseValue() {
+    this.skipWhitespace();
+    if (this.atEnd()) {
+      throw new CanonicalJsonError("UNEXPECTED_END");
+    }
+    const c = this.text[this.pos];
+    if (c === "{") {
+      return this.parseObject();
+    }
+    if (c === "[") {
+      return this.parseArray();
+    }
+    if (c === '"') {
+      return this.parseString();
+    }
+    if (c === "-" || c >= "0" && c <= "9") {
+      return this.parseNumber();
+    }
+    if (this.text.startsWith("null", this.pos)) {
+      this.pos += 4;
+      return null;
+    }
+    if (this.text.startsWith("true", this.pos)) {
+      this.pos += 4;
+      return true;
+    }
+    if (this.text.startsWith("false", this.pos)) {
+      this.pos += 5;
+      return false;
+    }
+    throw new CanonicalJsonError("INVALID_TOKEN");
+  }
+  parseObject() {
+    this.pos++;
+    const members2 = /* @__PURE__ */ new Map();
+    this.skipWhitespace();
+    if (this.atEnd()) {
+      throw new CanonicalJsonError("UNEXPECTED_END");
+    }
+    if (this.text[this.pos] === "}") {
+      this.pos++;
+      return members2;
+    }
+    for (; ; ) {
+      this.skipWhitespace();
+      if (this.atEnd()) {
+        throw new CanonicalJsonError("UNEXPECTED_END");
+      }
+      if (this.text[this.pos] !== '"') {
+        throw new CanonicalJsonError("INVALID_TOKEN");
+      }
+      const key = this.parseString();
+      if (members2.has(key)) {
+        throw new CanonicalJsonError("DUPLICATE_KEY");
+      }
+      this.skipWhitespace();
+      if (this.atEnd()) {
+        throw new CanonicalJsonError("UNEXPECTED_END");
+      }
+      if (this.text[this.pos] !== ":") {
+        throw new CanonicalJsonError("INVALID_TOKEN");
+      }
+      this.pos++;
+      members2.set(key, this.parseValue());
+      this.skipWhitespace();
+      if (this.atEnd()) {
+        throw new CanonicalJsonError("UNEXPECTED_END");
+      }
+      const next = this.text[this.pos];
+      if (next === ",") {
+        this.pos++;
+        continue;
+      }
+      if (next === "}") {
+        this.pos++;
+        return members2;
+      }
+      throw new CanonicalJsonError("INVALID_TOKEN");
+    }
+  }
+  parseArray() {
+    this.pos++;
+    const items = [];
+    this.skipWhitespace();
+    if (this.atEnd()) {
+      throw new CanonicalJsonError("UNEXPECTED_END");
+    }
+    if (this.text[this.pos] === "]") {
+      this.pos++;
+      return items;
+    }
+    for (; ; ) {
+      items.push(this.parseValue());
+      this.skipWhitespace();
+      if (this.atEnd()) {
+        throw new CanonicalJsonError("UNEXPECTED_END");
+      }
+      const next = this.text[this.pos];
+      if (next === ",") {
+        this.pos++;
+        continue;
+      }
+      if (next === "]") {
+        this.pos++;
+        return items;
+      }
+      throw new CanonicalJsonError("INVALID_TOKEN");
+    }
+  }
+  parseString() {
+    this.pos++;
+    let out = "";
+    for (; ; ) {
+      if (this.atEnd()) {
+        throw new CanonicalJsonError("UNEXPECTED_END");
+      }
+      const c = this.text[this.pos];
+      const code = this.text.charCodeAt(this.pos);
+      if (c === '"') {
+        this.pos++;
+        return out;
+      }
+      if (c === "\\") {
+        out += this.parseEscape();
+        continue;
+      }
+      if (code < 32) {
+        throw new CanonicalJsonError("INVALID_TOKEN");
+      }
+      out += c;
+      this.pos++;
+    }
+  }
+  parseEscape() {
+    this.pos++;
+    if (this.atEnd()) {
+      throw new CanonicalJsonError("UNEXPECTED_END");
+    }
+    const c = this.text[this.pos];
+    this.pos++;
+    switch (c) {
+      case '"':
+        return '"';
+      case "\\":
+        return "\\";
+      case "/":
+        return "/";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case "n":
+        return "\n";
+      case "r":
+        return "\r";
+      case "t":
+        return "	";
+      case "u":
+        return this.parseUnicodeEscape();
+      default:
+        throw new CanonicalJsonError("INVALID_ESCAPE");
+    }
+  }
+  parseUnicodeEscape() {
+    const high = this.readHex4();
+    if (high >= 56320 && high <= 57343) {
+      throw new CanonicalJsonError("INVALID_ESCAPE");
+    }
+    if (high < 55296 || high > 56319) {
+      return String.fromCharCode(high);
+    }
+    if (this.text[this.pos] !== "\\" || this.text[this.pos + 1] !== "u") {
+      throw new CanonicalJsonError("INVALID_ESCAPE");
+    }
+    this.pos += 2;
+    const low = this.readHex4();
+    if (low < 56320 || low > 57343) {
+      throw new CanonicalJsonError("INVALID_ESCAPE");
+    }
+    return String.fromCharCode(high, low);
+  }
+  readHex4() {
+    if (this.pos + 4 > this.text.length) {
+      throw new CanonicalJsonError("UNEXPECTED_END");
+    }
+    const hex = this.text.slice(this.pos, this.pos + 4);
+    if (!/^[0-9a-fA-F]{4}$/.test(hex)) {
+      throw new CanonicalJsonError("INVALID_ESCAPE");
+    }
+    this.pos += 4;
+    return parseInt(hex, 16);
+  }
+  parseNumber() {
+    const start = this.pos;
+    if (this.text[this.pos] === "-") {
+      this.pos++;
+    }
+    if (this.atEnd()) {
+      throw new CanonicalJsonError("UNEXPECTED_END");
+    }
+    const first = this.text[this.pos];
+    if (first < "0" || first > "9") {
+      throw new CanonicalJsonError("INVALID_TOKEN");
+    }
+    if (first === "0") {
+      this.pos++;
+    } else {
+      while (!this.atEnd() && this.text[this.pos] >= "0" && this.text[this.pos] <= "9") {
+        this.pos++;
+      }
+    }
+    if (!this.atEnd()) {
+      const next = this.text[this.pos];
+      if (next >= "0" && next <= "9") {
+        throw new CanonicalJsonError("INVALID_TOKEN");
+      }
+      if (next === "." || next === "e" || next === "E") {
+        throw new CanonicalJsonError("NON_INTEGER_NUMBER");
+      }
+    }
+    const value = BigInt(this.text.slice(start, this.pos));
+    if (value < INT64_MIN || value > INT64_MAX) {
+      throw new CanonicalJsonError("INTEGER_OUT_OF_RANGE");
+    }
+    return value;
+  }
+};
+function encodeCanonicalJson(value) {
+  return new TextEncoder().encode(encodeToString(value));
+}
+function encodeToString(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "string") {
+    return encodeString(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map(encodeToString).join(",")}]`;
+  }
+  const keys = [...value.keys()].sort(compareByCodePoints);
+  const members2 = keys.map((key) => `${encodeString(key)}:${encodeToString(value.get(key))}`);
+  return `{${members2.join(",")}}`;
+}
+function compareByCodePoints(a, b) {
+  let i = 0;
+  let j = 0;
+  while (i < a.length && j < b.length) {
+    const ca = a.codePointAt(i);
+    const cb = b.codePointAt(j);
+    if (ca !== cb) {
+      return ca - cb;
+    }
+    i += ca > 65535 ? 2 : 1;
+    j += cb > 65535 ? 2 : 1;
+  }
+  return a.length - i - (b.length - j);
+}
+function encodeString(value) {
+  let out = '"';
+  for (const ch of value) {
+    const code = ch.codePointAt(0);
+    if (ch === '"') {
+      out += '\\"';
+    } else if (ch === "\\") {
+      out += "\\\\";
+    } else if (code === 8) {
+      out += "\\b";
+    } else if (code === 12) {
+      out += "\\f";
+    } else if (code === 10) {
+      out += "\\n";
+    } else if (code === 13) {
+      out += "\\r";
+    } else if (code === 9) {
+      out += "\\t";
+    } else if (code < 32) {
+      out += `\\u00${code.toString(16).padStart(2, "0")}`;
+    } else {
+      out += ch;
+    }
+  }
+  return out + '"';
+}
+
+// src/server/client-proof/proof.ts
+import { createHash, createHmac, timingSafeEqual } from "crypto";
+var CLIENT_PROOF_PROFILE = "clientProofV1";
+var ABSENT_BODY_SHA256 = "0".repeat(64);
+var DEFAULT_REPLAY_WINDOW_MILLIS = 3e5;
+var ProofInputError = class extends Error {
+  constructor() {
+    super("proof input field contains a C0 control character");
+    this.name = "ProofInputError";
+  }
+};
+function canonicalProofInput(input) {
+  const fields = [
+    CLIENT_PROOF_PROFILE,
+    input.method,
+    input.path,
+    input.clientId,
+    input.keyId,
+    input.nonce,
+    input.issuedAtMillis.toString(),
+    input.bodySha256
+  ];
+  for (const field of fields) {
+    for (const ch of field) {
+      if (ch.codePointAt(0) < 32) {
+        throw new ProofInputError();
+      }
+    }
+  }
+  return fields.join("\n");
+}
+function computeClientProof(input, key) {
+  return createHmac("sha256", key).update(canonicalProofInput(input), "utf8").digest("hex");
+}
+function sha256Hex(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function constantTimeEqualsProof(expected, presented) {
+  const a = Buffer.from(expected, "utf8");
+  const b = Buffer.from(presented, "utf8");
+  if (a.length !== b.length) {
+    return false;
+  }
+  return timingSafeEqual(a, b);
+}
+
+// src/server/client-proof/refusal.ts
+import { randomBytes } from "crypto";
+var HTTP_STATUS = {
+  PROOF_INVALID: 401,
+  PROOF_REPLAYED: 401,
+  PROOF_EXPIRED: 401,
+  SESSION_REVOKED: 401,
+  PROFILE_REJECTED: 400,
+  CONTRACT_UNSUPPORTED: 409
+};
+function newHexId() {
+  return randomBytes(16).toString("hex");
+}
+var ClientProofRefusal = class _ClientProofRefusal {
+  constructor(code, message) {
+    this.code = code;
+    this.message = message;
+  }
+  get httpStatus() {
+    return HTTP_STATUS[this.code];
+  }
+  /** The canonical bytes of `{"error":{"code":…,"message":…,"requestId":…}}`. */
+  envelopeBytes(requestId) {
+    const error = /* @__PURE__ */ new Map([
+      ["code", this.code],
+      ["message", this.message],
+      ["requestId", requestId]
+    ]);
+    return encodeCanonicalJson(/* @__PURE__ */ new Map([["error", error]]));
+  }
+  /** Nothing request-derived reaches a log through this. */
+  toString() {
+    return `ClientProofRefusal(${this.code})`;
+  }
+  // ---- shape: what arrived is not the contract (rule 2) -------------------
+  static unroutable() {
+    return contractViolation("no operation in this contract answers that method and path");
+  }
+  static malformedHeaders() {
+    return contractViolation("the request does not carry the contract header fields exactly once each");
+  }
+  static missingContentType() {
+    return contractViolation("a request that carries a body must declare the contract content type");
+  }
+  static bodyTooLarge() {
+    return contractViolation("the request body exceeds the size this server accepts");
+  }
+  /**
+   * The body parsed but its bytes are not the canonical form of what it
+   * parsed to. Not PROOF_INVALID even though it is discovered next to the
+   * proof: the proof over these bytes verifies perfectly well, and an
+   * auth-family answer would tell the client to re-handshake and send the
+   * same non-canonical bytes again.
+   */
+  static bodyNotCanonical() {
+    return contractViolation("the request body is not the canonical JSON form of the value it encodes");
+  }
+  static bodyNotTheDeclaredType() {
+    return contractViolation("the request body is not the request type this operation declares");
+  }
+  static sessionHeaderMisplaced() {
+    return contractViolation("the session header is present exactly on the operations that require one");
+  }
+  static unprocessable() {
+    return contractViolation("the request could not be processed");
+  }
+  // ---- the profile allowlist ----------------------------------------------
+  static profileRejected() {
+    return new _ClientProofRefusal("PROFILE_REJECTED", "the named auth profile is not on this contract's allowlist");
+  }
+  // ---- auth: a new session might clear it (rule 1) -------------------------
+  static sessionRevoked() {
+    return new _ClientProofRefusal("SESSION_REVOKED", "the key or session was revoked");
+  }
+  static proofExpired() {
+    return new _ClientProofRefusal("PROOF_EXPIRED", "issuedAtMillis falls outside the replay window");
+  }
+  static proofReplayed() {
+    return new _ClientProofRefusal("PROOF_REPLAYED", "the nonce was already used inside the replay window");
+  }
+  static proofInvalid() {
+    return new _ClientProofRefusal("PROOF_INVALID", "the client proof did not verify");
+  }
+};
+function contractViolation(message) {
+  return new ClientProofRefusal("CONTRACT_UNSUPPORTED", message);
+}
+
+// src/server/client-proof/state.ts
+function systemClock() {
+  return { nowMillis: () => Date.now() };
+}
+var TestClock = class {
+  constructor(millis) {
+    this.millis = millis;
+  }
+  nowMillis() {
+    return this.millis;
+  }
+  advance(byMillis) {
+    this.millis += byMillis;
+  }
+};
+var DEFAULT_SESSION_TTL_MILLIS = 6e5;
+function replayKeyOf(clientId, nonce) {
+  return `${clientId}${nonce}`;
+}
+var ClientProofState = class {
+  replayWindowMillis;
+  clock;
+  keys = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  /** replayKeyOf(...) → the issuedAtMillis it was spent at. */
+  spentNonces = /* @__PURE__ */ new Map();
+  revokedKeyIds = /* @__PURE__ */ new Set();
+  holds = /* @__PURE__ */ new Map();
+  initialSessionTtlMillis;
+  sessionTtlMillis;
+  requestCount = 0;
+  handshakeCount = 0;
+  echoCount = 0;
+  itemsListCount = 0;
+  refusalCount = 0;
+  constructor(options) {
+    this.clock = options.clock ?? systemClock();
+    this.initialSessionTtlMillis = options.sessionTtlMillis ?? DEFAULT_SESSION_TTL_MILLIS;
+    this.sessionTtlMillis = this.initialSessionTtlMillis;
+    this.replayWindowMillis = options.replayWindowMillis ?? DEFAULT_REPLAY_WINDOW_MILLIS;
+    for (const [keyId, key] of Object.entries(options.keys)) {
+      this.keys.set(keyId, typeof key === "string" ? new TextEncoder().encode(key) : key);
+    }
+  }
+  // ---- admission ---------------------------------------------------------
+  /**
+   * Runs the contract's checks in the contract's order and returns the
+   * refusal, or null when the request is admitted (spending its nonce).
+   */
+  admit(args) {
+    const now = this.clock.nowMillis();
+    this.prune(now);
+    if (this.revokedKeyIds.has(args.keyId)) {
+      return ClientProofRefusal.sessionRevoked();
+    }
+    if (args.requiresSession) {
+      const session = args.presentedSessionId === null ? void 0 : this.sessions.get(args.presentedSessionId);
+      if (session === void 0 || session.expiresAtMillis <= now || session.keyId !== args.keyId || session.clientId !== args.clientId) {
+        return ClientProofRefusal.sessionRevoked();
+      }
+    }
+    const age = now - Number(args.proofInput.issuedAtMillis);
+    if (age < 0 || age > this.replayWindowMillis) {
+      return ClientProofRefusal.proofExpired();
+    }
+    const replayKey = replayKeyOf(args.clientId, args.proofInput.nonce);
+    if (this.spentNonces.has(replayKey)) {
+      return ClientProofRefusal.proofReplayed();
+    }
+    const key = this.keys.get(args.keyId);
+    if (key === void 0) {
+      return ClientProofRefusal.proofInvalid();
+    }
+    if (!constantTimeEqualsProof(computeClientProof(args.proofInput, key), args.presentedProof)) {
+      return ClientProofRefusal.proofInvalid();
+    }
+    this.spentNonces.set(replayKey, Number(args.proofInput.issuedAtMillis));
+    return null;
+  }
+  // ---- sessions ----------------------------------------------------------
+  /** Opens a session and returns its id and the expiry the server advertises. */
+  openSession(clientId, keyId) {
+    const now = this.clock.nowMillis();
+    this.prune(now);
+    const sessionId = newHexId();
+    const expiresAtMillis = now + this.sessionTtlMillis;
+    this.sessions.set(sessionId, { clientId, keyId, expiresAtMillis });
+    return { sessionId, expiresAtMillis };
+  }
+  /** Test hook: installs a session with a chosen id (wire-fixture replays). */
+  seedSession(sessionId, clientId, keyId, expiresAtMillis) {
+    this.sessions.set(sessionId, { clientId, keyId, expiresAtMillis });
+  }
+  /** Drops every session, as a restart would. Advertised expiries stay told. */
+  expireSessions() {
+    this.sessions.clear();
+  }
+  /** Revokes a key and drops the sessions it opened. */
+  revokeKey(keyId) {
+    this.revokedKeyIds.add(keyId);
+    for (const [sessionId, session] of this.sessions) {
+      if (session.keyId === keyId) {
+        this.sessions.delete(sessionId);
+      }
+    }
+  }
+  setSessionTtlMillis(millis) {
+    this.sessionTtlMillis = millis;
+  }
+  /** Returns the state to how it started, counters included. */
+  reset() {
+    this.sessions.clear();
+    this.spentNonces.clear();
+    this.revokedKeyIds.clear();
+    this.holds.clear();
+    this.sessionTtlMillis = this.initialSessionTtlMillis;
+    this.requestCount = 0;
+    this.handshakeCount = 0;
+    this.echoCount = 0;
+    this.itemsListCount = 0;
+    this.refusalCount = 0;
+  }
+  // ---- delays (dev/test only) --------------------------------------------
+  /** Makes the next `count` requests to `path` wait `millis` before processing. */
+  holdPath(path, millis, count) {
+    this.holds.set(path, { millis, remaining: count });
+  }
+  /** Consumes one configured delay for `path`; returns how long to wait, or 0. */
+  takeHoldMillis(path) {
+    const hold2 = this.holds.get(path);
+    if (hold2 === void 0) {
+      return 0;
+    }
+    hold2.remaining -= 1;
+    if (hold2.remaining <= 0) {
+      this.holds.delete(path);
+    }
+    return hold2.millis;
+  }
+  // ---- counters ----------------------------------------------------------
+  recordRequest() {
+    this.requestCount += 1;
+  }
+  recordOperation(operationId) {
+    if (operationId === "auth.clientProof.handshake") {
+      this.handshakeCount += 1;
+    } else if (operationId === "echo.send") {
+      this.echoCount += 1;
+    } else if (operationId === "items.list") {
+      this.itemsListCount += 1;
+    }
+  }
+  recordRefusal() {
+    this.refusalCount += 1;
+  }
+  stats() {
+    this.prune(this.clock.nowMillis());
+    return {
+      requestCount: this.requestCount,
+      handshakeCount: this.handshakeCount,
+      echoCount: this.echoCount,
+      itemsListCount: this.itemsListCount,
+      refusalCount: this.refusalCount,
+      liveSessionCount: this.sessions.size,
+      spentNonceCount: this.spentNonces.size
+    };
+  }
+  nowMillis() {
+    return this.clock.nowMillis();
+  }
+  /** The clock, exposed for the dev control surface's advance-clock route. */
+  get clockRef() {
+    return this.clock;
+  }
+  // ---- housekeeping ------------------------------------------------------
+  /**
+   * Drops what can no longer affect an answer. The nonce predicate is the
+   * exact negation of the window check in `admit`: an entry is dropped only
+   * once a proof carrying that issuedAtMillis would be refused as expired
+   * anyway. Dropping one moment earlier would let a nonce inside the window
+   * be spent twice.
+   */
+  prune(nowMillis) {
+    for (const [sessionId, session] of this.sessions) {
+      if (session.expiresAtMillis <= nowMillis) {
+        this.sessions.delete(sessionId);
+      }
+    }
+    for (const [key, issuedAtMillis] of this.spentNonces) {
+      if (nowMillis - issuedAtMillis > this.replayWindowMillis) {
+        this.spentNonces.delete(key);
+      }
+    }
+  }
+};
+
+// src/server/client-proof/admission.ts
+var CLIENT_PROOF_HEADERS = {
+  profile: "x-spfn-auth-profile",
+  clientId: "x-spfn-client-id",
+  keyId: "x-spfn-key-id",
+  nonce: "x-spfn-nonce",
+  issuedAtMillis: "x-spfn-issued-at",
+  proof: "x-spfn-proof",
+  session: "x-spfn-session"
+};
+var CLIENT_PROOF_CONTENT_TYPE = "application/json";
+var INT64_MIN2 = -(2n ** 63n);
+var INT64_MAX2 = 2n ** 63n - 1n;
+function admitClientProofRequest(args) {
+  const credentials = readCredentials(args.headers);
+  if (credentials === null) {
+    return refused(ClientProofRefusal.malformedHeaders());
+  }
+  if (credentials.profile !== CLIENT_PROOF_PROFILE) {
+    return refused(ClientProofRefusal.profileRejected());
+  }
+  if (!isRequestContentType(args.headers.get("content-type"))) {
+    return refused(ClientProofRefusal.missingContentType());
+  }
+  if (args.requiresSession !== (credentials.sessionId !== null)) {
+    return refused(ClientProofRefusal.sessionHeaderMisplaced());
+  }
+  let value;
+  try {
+    value = parseCanonicalJson(args.body);
+  } catch {
+    return refused(ClientProofRefusal.bodyNotCanonical());
+  }
+  if (!isCanonicalBytes(args.body, value)) {
+    return refused(ClientProofRefusal.bodyNotCanonical());
+  }
+  const proofInput = {
+    method: args.method,
+    path: args.path,
+    clientId: credentials.clientId,
+    keyId: credentials.keyId,
+    nonce: credentials.nonce,
+    issuedAtMillis: credentials.issuedAtMillis,
+    bodySha256: sha256Hex(args.body)
+  };
+  let refusal;
+  try {
+    refusal = args.state.admit({
+      clientId: credentials.clientId,
+      keyId: credentials.keyId,
+      presentedSessionId: credentials.sessionId,
+      requiresSession: args.requiresSession,
+      proofInput,
+      presentedProof: credentials.proof
+    });
+  } catch {
+    return refused(ClientProofRefusal.unprocessable());
+  }
+  if (refusal !== null) {
+    return refused(refusal);
+  }
+  return { admitted: true, value, credentials };
+}
+function refused(refusal) {
+  return { admitted: false, refusal };
+}
+function readCredentials(headers) {
+  const profile = headers.get(CLIENT_PROOF_HEADERS.profile);
+  const clientId = headers.get(CLIENT_PROOF_HEADERS.clientId);
+  const keyId = headers.get(CLIENT_PROOF_HEADERS.keyId);
+  const nonce = headers.get(CLIENT_PROOF_HEADERS.nonce);
+  const issuedAtRaw = headers.get(CLIENT_PROOF_HEADERS.issuedAtMillis);
+  const proof = headers.get(CLIENT_PROOF_HEADERS.proof);
+  if (profile === null || clientId === null || keyId === null || nonce === null || issuedAtRaw === null || proof === null) {
+    return null;
+  }
+  const issuedAtMillis = parseInt64(issuedAtRaw);
+  if (issuedAtMillis === null) {
+    return null;
+  }
+  return {
+    profile,
+    clientId,
+    keyId,
+    nonce,
+    issuedAtMillis,
+    proof,
+    sessionId: headers.get(CLIENT_PROOF_HEADERS.session)
+  };
+}
+function parseInt64(raw) {
+  if (!/^[+-]?\d{1,19}$/.test(raw)) {
+    return null;
+  }
+  const value = BigInt(raw);
+  if (value < INT64_MIN2 || value > INT64_MAX2) {
+    return null;
+  }
+  return value;
+}
+function isRequestContentType(value) {
+  if (value === null) {
+    return false;
+  }
+  return value.split(";")[0].trim().toLowerCase() === CLIENT_PROOF_CONTENT_TYPE;
+}
+
+// src/server/client-proof/contract-types.ts
+var CONTRACT_OPERATIONS = [
+  { id: "auth.clientProof.handshake", method: "POST", path: "/v1/auth/client-proof/handshake", requiresSession: false },
+  { id: "echo.send", method: "POST", path: "/v1/echo", requiresSession: true },
+  { id: "items.list", method: "POST", path: "/v1/items/list", requiresSession: true }
+];
+var ContractTypeError = class extends Error {
+  constructor() {
+    super("not the declared contract type");
+    this.name = "ContractTypeError";
+  }
+};
+function decodeHandshakeRequest(value) {
+  const members2 = objectWithKeys(value, ["clientId", "keyId", "nonce", "issuedAtMillis"], []);
+  return {
+    clientId: text(members2.get("clientId")),
+    keyId: text(members2.get("keyId")),
+    nonce: text(members2.get("nonce")),
+    issuedAtMillis: integer(members2.get("issuedAtMillis"))
+  };
+}
+function decodeEchoRequest(value) {
+  const members2 = objectWithKeys(value, ["message", "sequence"], []);
+  return {
+    message: text(members2.get("message")),
+    sequence: integer(members2.get("sequence"))
+  };
+}
+function decodeListItemsRequest(value) {
+  const members2 = objectWithKeys(value, ["limit"], ["cursor"]);
+  const request = { limit: integer(members2.get("limit")) };
+  if (members2.has("cursor")) {
+    request.cursor = text(members2.get("cursor"));
+  }
+  return request;
+}
+function objectWithKeys(value, required, optional) {
+  if (!(value instanceof Map)) {
+    throw new ContractTypeError();
+  }
+  for (const key of required) {
+    if (!value.has(key)) {
+      throw new ContractTypeError();
+    }
+  }
+  for (const key of value.keys()) {
+    if (!required.includes(key) && !optional.includes(key)) {
+      throw new ContractTypeError();
+    }
+  }
+  return value;
+}
+function text(value) {
+  if (typeof value !== "string") {
+    throw new ContractTypeError();
+  }
+  return value;
+}
+function integer(value) {
+  if (typeof value !== "bigint") {
+    throw new ContractTypeError();
+  }
+  return value;
+}
+function encodeHandshakeResponse(sessionId, expiresAtMillis) {
+  return /* @__PURE__ */ new Map([
+    ["sessionId", sessionId],
+    ["expiresAtMillis", expiresAtMillis]
+  ]);
+}
+function encodeEchoResponse(message, sequence, serverTimeMillis) {
+  return /* @__PURE__ */ new Map([
+    ["message", message],
+    ["sequence", sequence],
+    ["serverTimeMillis", serverTimeMillis]
+  ]);
+}
+function encodeListItemsResponse(items, nextCursor) {
+  const encodedItems = items.map((item) => /* @__PURE__ */ new Map([
+    ["id", item.id],
+    ["name", item.name],
+    ["updatedAtMillis", item.updatedAtMillis]
+  ]));
+  const members2 = /* @__PURE__ */ new Map([["items", encodedItems]]);
+  if (nextCursor !== null) {
+    members2.set("nextCursor", nextCursor);
+  }
+  return members2;
+}
+
+// src/server/client-proof/dev-control.ts
+var CONTROL_PREFIX = "/control/";
+var CONTROL_TOKEN_HEADER = "x-spfn-reference-control";
+var HTTP_OK = 200;
+var HTTP_BAD_REQUEST = 400;
+var HTTP_FORBIDDEN = 403;
+var HTTP_NOT_FOUND = 404;
+var HTTP_CONFLICT = 409;
+var MAX_CONTROL_BODY_BYTES = 4096;
+async function handleControlRequest(state, controlToken, path, request) {
+  if (path === "/control/health") {
+    return answer(HTTP_OK, /* @__PURE__ */ new Map([["status", "ok"]]));
+  }
+  if (request.headers.get(CONTROL_TOKEN_HEADER) !== controlToken) {
+    return answer(HTTP_FORBIDDEN, failure("control token"));
+  }
+  const raw = new Uint8Array(await request.arrayBuffer());
+  const body = raw.length > MAX_CONTROL_BODY_BYTES ? raw.slice(0, MAX_CONTROL_BODY_BYTES) : raw;
+  switch (path) {
+    case "/control/stats":
+      return stats(state);
+    case "/control/reset":
+      state.reset();
+      return ok();
+    case "/control/expire-sessions":
+      state.expireSessions();
+      return ok();
+    case "/control/revoke-key":
+      return revokeKey(state, body);
+    case "/control/session-ttl":
+      return sessionTtl(state, body);
+    case "/control/hold":
+      return hold(state, body);
+    case "/control/advance-clock":
+      return advanceClock(state, body);
+    default:
+      return answer(HTTP_NOT_FOUND, failure("unknown control route"));
+  }
+}
+function stats(state) {
+  const counters = state.stats();
+  return answer(HTTP_OK, withOk(/* @__PURE__ */ new Map([
+    ["echoCount", BigInt(counters.echoCount)],
+    ["handshakeCount", BigInt(counters.handshakeCount)],
+    ["itemsListCount", BigInt(counters.itemsListCount)],
+    ["liveSessionCount", BigInt(counters.liveSessionCount)],
+    ["refusalCount", BigInt(counters.refusalCount)],
+    ["requestCount", BigInt(counters.requestCount)],
+    ["spentNonceCount", BigInt(counters.spentNonceCount)]
+  ])));
+}
+function revokeKey(state, body) {
+  const keyId = stringField(body, "keyId");
+  if (keyId === null) {
+    return badRequest("keyId");
+  }
+  state.revokeKey(keyId);
+  return ok();
+}
+function sessionTtl(state, body) {
+  const ttlMillis = integerField(body, "ttlMillis");
+  if (ttlMillis === null) {
+    return badRequest("ttlMillis");
+  }
+  state.setSessionTtlMillis(Number(ttlMillis));
+  return ok();
+}
+function hold(state, body) {
+  const path = stringField(body, "path");
+  const millis = integerField(body, "millis");
+  const count = integerField(body, "count");
+  if (path === null) {
+    return badRequest("path");
+  }
+  if (millis === null) {
+    return badRequest("millis");
+  }
+  if (count === null) {
+    return badRequest("count");
+  }
+  state.holdPath(path, Number(millis), Number(count));
+  return ok();
+}
+function advanceClock(state, body) {
+  const clock = state.clockRef;
+  if (!(clock instanceof TestClock)) {
+    return answer(HTTP_CONFLICT, failure("server is running on the system clock"));
+  }
+  const millis = integerField(body, "millis");
+  if (millis === null) {
+    return badRequest("millis");
+  }
+  clock.advance(Number(millis));
+  return ok();
+}
+function members(body) {
+  if (body.length === 0) {
+    return /* @__PURE__ */ new Map();
+  }
+  let parsed;
+  try {
+    parsed = parseCanonicalJson(body);
+  } catch {
+    return null;
+  }
+  return parsed instanceof Map ? parsed : null;
+}
+function stringField(body, field) {
+  const value = members(body)?.get(field);
+  return typeof value === "string" ? value : null;
+}
+function integerField(body, field) {
+  const value = members(body)?.get(field);
+  return typeof value === "bigint" ? value : null;
+}
+function badRequest(field) {
+  return answer(HTTP_BAD_REQUEST, failure(`missing or malformed field: ${field}`));
+}
+function ok() {
+  return answer(HTTP_OK, withOk(/* @__PURE__ */ new Map()));
+}
+function failure(reason) {
+  return /* @__PURE__ */ new Map([["ok", false], ["reason", reason]]);
+}
+function withOk(extra) {
+  extra.set("ok", true);
+  return extra;
+}
+function answer(status, value) {
+  const bytes = encodeCanonicalJson(value);
+  const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  return new Response(buffer, { status, headers: { "content-type": "application/json" } });
+}
+
+// src/server/client-proof/dev-handler.ts
+var MAX_BODY_BYTES = 1 << 20;
+var HTTP_OK2 = 200;
+var DEV_CATALOGUE = [
+  { id: "item-0001", name: "alpha", updatedAtMillis: 1750000000001n },
+  { id: "item-0002", name: "bravo", updatedAtMillis: 1750000000002n },
+  { id: "item-0003", name: "charlie", updatedAtMillis: 1750000000003n },
+  { id: "item-0004", name: "delta", updatedAtMillis: 1750000000004n },
+  { id: "item-0005", name: "echo", updatedAtMillis: 1750000000005n }
+];
+var DEV_MAX_LIMIT = 100n;
+function createClientProofDevHandler(options) {
+  const state = new ClientProofState(options);
+  const controlToken = options.controlToken ?? newHexId();
+  const enableControl = options.enableControl ?? true;
+  const log = options.log ?? (() => void 0);
+  async function dispatch(request) {
+    state.recordRequest();
+    const url = new URL(request.url);
+    if (enableControl && url.pathname.startsWith(CONTROL_PREFIX)) {
+      return handleControlRequest(state, controlToken, url.pathname, request);
+    }
+    const operation = url.search === "" ? CONTRACT_OPERATIONS.find((op) => op.path === url.pathname && op.method === request.method) : void 0;
+    if (operation === void 0) {
+      return refuse(ClientProofRefusal.unroutable());
+    }
+    const body = await readBodyCapped(request);
+    if (body === null) {
+      return refuse(ClientProofRefusal.bodyTooLarge());
+    }
+    await waitOutHold(url.pathname);
+    const admission = admitClientProofRequest({
+      state,
+      headers: request.headers,
+      method: operation.method,
+      path: operation.path,
+      requiresSession: operation.requiresSession,
+      body
+    });
+    if (!admission.admitted) {
+      return refuse(admission.refusal);
+    }
+    return apply(operation, admission);
+  }
+  function apply(operation, admission) {
+    let value;
+    try {
+      if (operation.id === "auth.clientProof.handshake") {
+        const request = decodeHandshakeRequest(admission.value);
+        if (request.clientId !== admission.credentials.clientId || request.keyId !== admission.credentials.keyId) {
+          return refuse(ClientProofRefusal.bodyNotTheDeclaredType());
+        }
+        const opened = state.openSession(request.clientId, request.keyId);
+        value = encodeHandshakeResponse(opened.sessionId, BigInt(opened.expiresAtMillis));
+      } else if (operation.id === "echo.send") {
+        const request = decodeEchoRequest(admission.value);
+        value = encodeEchoResponse(request.message, request.sequence, BigInt(state.nowMillis()));
+      } else {
+        const listed = listItems(decodeListItemsRequest(admission.value));
+        if (listed === null) {
+          return refuse(ClientProofRefusal.bodyNotTheDeclaredType());
+        }
+        value = listed;
+      }
+    } catch (error) {
+      if (error instanceof ContractTypeError) {
+        return refuse(ClientProofRefusal.bodyNotTheDeclaredType());
+      }
+      return refuse(ClientProofRefusal.unprocessable());
+    }
+    state.recordOperation(operation.id);
+    return contractResponse(HTTP_OK2, encodeCanonicalJson(value));
+  }
+  function refuse(refusal) {
+    state.recordRefusal();
+    return contractResponse(refusal.httpStatus, refusal.envelopeBytes(newHexId()));
+  }
+  async function waitOutHold(path) {
+    const millis = state.takeHoldMillis(path);
+    if (millis > 0) {
+      await new Promise((resolve) => setTimeout(resolve, millis));
+    }
+  }
+  return {
+    state,
+    controlToken,
+    fetch: async (request) => {
+      try {
+        const response = await dispatch(request);
+        log(`${request.method} ${new URL(request.url).pathname} -> ${response.status}`);
+        return response;
+      } catch {
+        return refuse(ClientProofRefusal.unprocessable());
+      }
+    }
+  };
+}
+function listItems(request) {
+  if (request.limit < 1n || request.limit > DEV_MAX_LIMIT) {
+    return null;
+  }
+  let start = 0;
+  if (request.cursor !== void 0) {
+    const index = DEV_CATALOGUE.findIndex((item) => item.id === request.cursor);
+    if (index < 0) {
+      return null;
+    }
+    start = index + 1;
+  }
+  const end = Math.min(DEV_CATALOGUE.length, start + Number(request.limit));
+  const page = DEV_CATALOGUE.slice(start, end);
+  const nextCursor = end < DEV_CATALOGUE.length && page.length > 0 ? page[page.length - 1].id : null;
+  return encodeListItemsResponse([...page], nextCursor);
+}
+function contractResponse(status, body) {
+  return new Response(toArrayBuffer(body), {
+    status,
+    headers: { "content-type": "application/json" }
+  });
+}
+async function readBodyCapped(request) {
+  if (request.body === null) {
+    return new Uint8Array(0);
+  }
+  const reader = request.body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    total += value.length;
+    if (total > MAX_BODY_BYTES) {
+      await reader.cancel();
+      return null;
+    }
+    chunks.push(value);
+  }
+  const body = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    body.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return body;
+}
+function toArrayBuffer(bytes) {
+  return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+}
+
+// src/server/client-proof/guard.ts
+function createClientProofGuard(state, options = {}) {
+  return async (c, next) => {
+    const body = new Uint8Array(await c.req.arrayBuffer());
+    const admission = admitClientProofRequest({
+      state,
+      headers: c.req.raw.headers,
+      method: c.req.method,
+      path: options.contractPath ?? c.req.path,
+      requiresSession: true,
+      body
+    });
+    if (!admission.admitted) {
+      state.recordRefusal();
+      const bytes = admission.refusal.envelopeBytes(newHexId());
+      const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+      return c.newResponse(buffer, admission.refusal.httpStatus, {
+        "content-type": "application/json"
+      });
+    }
+    c.set("clientType", "mobile");
+    c.set("clientProof", {
+      credentials: admission.credentials,
+      value: admission.value
+    });
+    await next();
+    return void 0;
+  };
+}
+export {
+  ABSENT_BODY_SHA256,
+  CLIENT_PROOF_CONTENT_TYPE,
+  CLIENT_PROOF_HEADERS,
+  CLIENT_PROOF_PROFILE,
+  CONTRACT_OPERATIONS,
+  CONTROL_PREFIX,
+  CONTROL_TOKEN_HEADER,
+  CanonicalJsonError,
+  ClientProofRefusal,
+  ClientProofState,
+  ContractTypeError,
+  DEFAULT_REPLAY_WINDOW_MILLIS,
+  DEFAULT_SESSION_TTL_MILLIS,
+  DEV_CATALOGUE,
+  DEV_MAX_LIMIT,
+  ProofInputError,
+  TestClock,
+  admitClientProofRequest,
+  canonicalProofInput,
+  computeClientProof,
+  constantTimeEqualsProof,
+  createClientProofDevHandler,
+  createClientProofGuard,
+  decodeEchoRequest,
+  decodeHandshakeRequest,
+  decodeListItemsRequest,
+  encodeCanonicalJson,
+  encodeEchoResponse,
+  encodeHandshakeResponse,
+  encodeListItemsResponse,
+  isCanonicalBytes,
+  newHexId,
+  parseCanonicalJson,
+  sha256Hex,
+  systemClock
+};
+//# sourceMappingURL=client-proof.js.map