Server-Blind Sync Layer

async function deriveSyncKeys(rawToken: string) {
  const encoder = new TextEncoder();
  const tokenBytes = encoder.encode(rawToken);

  // Import raw token bytes into an HKDF-capable CryptoKey object
  const baseKey = await crypto.subtle.importKey(
    "raw",
    tokenBytes,
    { name: "HKDF" },
    false,
    ["deriveBits", "deriveKey"]
  );

  // 1. Derive lookup address (32 bytes)
  const addressBuffer = await crypto.subtle.deriveBits(
    {
      name: "HKDF",
      hash: "SHA-256",
      salt: new Uint8Array(32), // 32-byte zero salt
      info: encoder.encode("nid-db-address")
    },
    baseKey,
    256 // 32 bytes * 8 bits
  );
  const address = arrayBufferToHex(addressBuffer);

  // 2. Derive AES-GCM Encryption Key
  const encryptionKey = await crypto.subtle.deriveKey(
    {
      name: "HKDF",
      hash: "SHA-256",
      salt: new Uint8Array(32),
      info: encoder.encode("nid-encryption-key")
    },
    baseKey,
    { name: "AES-GCM", length: 256 },
    false,
    ["encrypt", "decrypt"]
  );

  // 3. Derive Verification Key (used for HMAC write token generation)
  const verifyKey = await crypto.subtle.deriveKey(
    {
      name: "HKDF",
      hash: "SHA-256",
      salt: new Uint8Array(32),
      info: encoder.encode("nid-verification-key")
    },
    baseKey,
    { name: "HMAC", hash: "SHA-256", length: 256 },
    false,
    ["sign"]
  );

  // 4. Compute Write Signature Auth Token (HMAC signature of static tag)
  const signatureBuffer = await crypto.subtle.sign(
    "HMAC",
    verifyKey,
    encoder.encode("nid-write-auth")
  );
  const writeToken = arrayBufferToHex(signatureBuffer);

  return { address, encryptionKey, writeToken };
}

// Inside Cloudflare Worker routing controller...
export async function handlePutRequest(request: Request, env: Env) {
  const { address } = request.params;
  const { blob, writeToken, verifyKeyHex, previousHash } = await request.json();

  const record = await env.NOTES_KV.get(address, { type: "json" });

  if (!record) {
    // First-time write: store the verifyKey and the encrypted blob
    await env.NOTES_KV.put(address, JSON.stringify({
      blob,
      verifyKey: verifyKeyHex,
      hash: await sha256(blob)
    }));
    return new Response("Created", { status: 201 });
  }

  // Subsequent writes: Import verifyKey and verify client's writeToken
  const verifyKey = await importHmacKey(record.verifyKey);
  const isValid = await verifyHmacSignature(verifyKey, writeToken, "nid-write-auth");

  if (!isValid) {
    return new Response("Unauthorized Signature", { status: 401 });
  }

  // Compare-and-Swap (CAS) check to prevent overwrite race conditions
  if (record.hash !== previousHash) {
    return new Response("Conflict: database updated elsewhere", { status: 409 });
  }

  // Update blob and update current hash
  await env.NOTES_KV.put(address, JSON.stringify({
    blob,
    verifyKey: record.verifyKey,
    hash: await sha256(blob)
  }));
  return new Response("OK", { status: 200 });
}