Added example/dropin replacements for .env.example

Fixed the issue with PlainText (Complete Anon) posting
Need to fix device sign on issues.
Need to make it so that the non-signed in devices can only see their equalivant level of posts. (i.e. plaintext, public-encrypted, private-encrypted)

.env.example

@@ -0,0 +1,7 @@
+CF_TUNNEL_TOKEN=YOUR_CF_TUNNEL_TOKEN_HERE
+GC_DISCORD_CLIENT_ID=YOUR_DISCORD_CLIENT_ID_HERE
+GC_DISCORD_CLIENT_SECRET=YOUR_DISCORD_CLIENT_SECRET_HERE
+GC_DISCORD_REDIRECT_URI=YOUR_DISCORD_REDIRECT_URI_HERE
+GC_SIGNING_SECRET_HEX=YOUR_SIGNING_SECRET_HEXKEY_HERE
+GC_ALLOW_ANON_PLAINTEXT=true # Enable PlainText
+GC_DEV_ALLOW_UNAUTH=true # False when public

.gitignore

@@ -23,3 +23,4 @@ data/
 # Env/config overrides
 shard.yaml
 .env
+testdata/*

Dockerfile

@@ -31,7 +31,7 @@ FROM gcr.io/distroless/base-debian12:nonroot
 WORKDIR /app
 COPY --from=build /out/greencoast-shard /app/greencoast-shard
 COPY configs/shard.sample.yaml /app/shard.yaml
-COPY client /app/client
+COPY client/ /opt/greencoast/client/
 VOLUME ["/var/lib/greencoast"]
 EXPOSE 8080 8081 8443 9443
 USER nonroot:nonroot

README.md

@@ -1,24 +1,224 @@
-# GreenCoast — Privacy-First, Shardable Social (Dockerized)
+# GreenCoast
 
-**Goal:** A BlueSky-like experience with **shards**, **zero-trust**, **no data collection**, **E2EE**, and easy self-hosting — from x86_64 down to **Raspberry Pi Zero**.  
+A privacy-first, shardable social backend + minimalist client. **Zero PII**, **zero passwords**, optional **E2EE per post**, and **public-key accounts**. Includes **DPoP-style proof-of-possession**, **Discord SSO with PKCE**, and a tiny static client.
-License: **The Unlicense** (public-domain equivalent).
-
-This repo contains a minimal, working **shard**: an append-only object API with zero-data-collection defaults. It’s structured to evolve into full federation, E2EE, and client apps, while keeping Pi Zero as a supported host.
 
 ---
 
-## Quick Start (Laptop / Dev)
+## Features
 
-**Requirements:** Docker + Compose v2
+- **Zero-trust by design**: server stores no emails or passwords.
+- **Accounts = public keys** (Ed25519 or P-256). No usernames required.
+- **Proof-of-possession (PoP)** on every authenticated API call.
+- **Short-lived tokens** (HMAC “gc2”) bound to device keys.
+- **Shardable storage** (mTLS or signed shard requests).
+- **No fingerprinting**: no IP/UA logs; coarse timestamps optional.
+- **Static client** with strong CSP; optional E2EE per post.
+- **Discord SSO (PKCE)** as an *optional* convenience.
+- **Filesystem storage** supports both **flat** and **nested** object layouts.
+
+---
+
+## Architecture (brief)
+
+- **Shard**: stateless API + local FS object store + in-memory index.
+- **Client**: static files (HTML/JS/CSS) served by the shard or any static host.
+- **Identity**: device key (P-256/Ed25519) or passkey; server mints short-lived **gc2** tokens bound to the device key (`cnf` claim).
+- **Privacy**: objects can be plaintext (public) or client-encrypted (private).
+
+---
+
+## Security posture
+
+- **Zero-trust**: no passwords/emails; optional SSO is *linking*, not source-of-truth.
+- **DPoP-style PoP** on requests:
+  - Client sends:
+    - `Authorization: Bearer gc2.…`
+    - `X-GC-Key: p256:<base64-raw>` (or `ed25519:…`)
+    - `X-GC-TS: <unix seconds>`
+    - `X-GC-Proof: sig( METHOD "\n" URL "\n" TS "\n" SHA256(body) )`
+  - Server verifies `gc2` signature, key binding (`cnf`), timestamp window, and replay cache.
+- **Replay protection**: 10-minute proof cache.
+- **No fingerprinting/logging**: no IPs, no UAs.
+- **Strict CSP** for client: blocks XSS/token theft.
+- **Limits**: request body limits (default 10 MiB), simple per-account rate limiting.
+- **Shard↔shard**: mTLS or per-shard signatures with timestamp + replay cache.
+
+---
+
+## Requirements
+
+- Go 1.21+  
+- Docker (optional)  
+- A signing key for tokens: `GC_SIGNING_SECRET_HEX` (32+ bytes hex)  
+- (Optional) Discord OAuth app (Client ID/Secret + redirect URI)  
+- (Optional) Cloudflare Tunnel or other TLS reverse proxy
+
+---
+
+## Environment variables
+
+    GC_HTTP_ADDR=:9080
+    GC_HTTPS_ADDR=                    # optional
+    GC_TLS_CERT=                      # optional
+    GC_TLS_KEY=                       # optional
+
+    GC_STATIC_ADDR=:9082
+    GC_STATIC_DIR=/opt/greencoast/client
+
+    GC_DATA_DIR=/var/lib/greencoast
+    GC_ZERO_TRUST=true
+    GC_COARSE_TS=false
+
+    GC_SIGNING_SECRET_HEX=<64+ hex chars>    # required for gc2 tokens
+    GC_REQUIRE_POP=true                      # default true; set false for first-run
+
+    # Dev convenience (testing only; disable for production)
+    GC_DEV_ALLOW_UNAUTH=false
+    GC_DEV_BEARER=
+
+    # Discord SSO (optional)
+    GC_DISCORD_CLIENT_ID=
+    GC_DISCORD_CLIENT_SECRET=
+    GC_DISCORD_REDIRECT_URI=https://greencoast.example.com/auth-callback.html
+
+---
+
+## Quickstart (Docker)
+
+Minimal compose for local testing (PoP disabled + dev unauth allowed for first run):
+
+    services:
+      shard-test:
+        build: .
+        environment:
+          - GC_HTTP_ADDR=:9080
+          - GC_STATIC_ADDR=:9082
+          - GC_STATIC_DIR=/opt/greencoast/client
+          - GC_DATA_DIR=/var/lib/greencoast
+          - GC_ZERO_TRUST=true
+          - GC_SIGNING_SECRET_HEX=7f6e1a0f2b4d7e3a...   # replace with your secret
+          - GC_REQUIRE_POP=false                      # easier first-run
+          - GC_DEV_ALLOW_UNAUTH=true
+        volumes:
+          - ./testdata:/var/lib/greencoast
+          - ./client:/opt/greencoast/client:ro
+        ports:
+          - "9080:9080"
+          - "9082:9082"
+
+Open `http://localhost:9082` → set the Shard URL (`http://localhost:9080`) → publish a test post.
+
+When ready, **turn PoP on** by removing `GC_REQUIRE_POP=false` and disabling `GC_DEV_ALLOW_UNAUTH`.
+
+---
+
+## Cloudflare Tunnel example
+
+    ingress:
+      - hostname: greencoast.example.com
+        service: http://shard-test:9082
+      - hostname: api-gc.greencoast.example.com
+        service: http://shard-test:9080
+      - service: http_status:404
+
+Use “Full (strict)” TLS and ensure your cert covers both hosts.
+
+---
+
+## Client usage
+
+- **Shard URL**: set it in the top “Connect” section (or use `?api=` query or `<meta name="gc-api-base">`).
+- **Device key sign-in (no OAuth)**:
+  1) Client generates/stores a P-256 device key in the browser.
+  2) Client calls `/v1/auth/key/challenge` then `/v1/auth/key/verify` to obtain a **gc2** token bound to that key.
+- **Discord SSO (optional)**:
+  - Requires `GC_DISCORD_CLIENT_*` env vars and a valid `GC_DISCORD_REDIRECT_URI`.
+  - Uses PKCE (`S256`) and binds the minted **gc2** token to the device key presented at `/start`.
+
+---
+
+## API (overview)
+
+- `GET  /healthz` – liveness
+- `PUT  /v1/object` – upload blob (headers: optional `X-GC-Private: 1`, `X-GC-TZ`)
+- `GET  /v1/object/{hash}` – download blob
+- `DELETE /v1/object/{hash}` – delete blob
+- `GET  /v1/index` – list indexed entries (latest first)
+- `GET  /v1/index/stream` – SSE updates
+- `POST /v1/admin/reindex` – rebuild index from disk
+- **Auth**
+  - `POST /v1/auth/key/challenge` → `{nonce, exp}`
+  - `POST /v1/auth/key/verify` `{nonce, alg, pub, sig}` → `{bearer, sub, exp}`
+  - `POST /v1/auth/discord/start` (requires `X-GC-3P-Assent: 1` and `X-GC-Key`)
+  - `GET  /v1/auth/discord/callback` → redirects with `#bearer=…`
+- **GDPR**
+  - `GET  /v1/gdpr/policy` – current data-handling posture
+
+> When `GC_REQUIRE_POP=true`, all authenticated endpoints require PoP headers.
+
+### PoP header format (pseudocode)
+
+    Authorization: Bearer gc2.<claims>.<sig>
+    X-GC-Key: p256:<base64-raw>          # or ed25519:<base64-raw>
+    X-GC-TS: <unix seconds>
+    X-GC-Proof: base64(
+        Sign_device_key(
+          UPPER(METHOD) + "\n" + URL + "\n" + X-GC-TS + "\n" + SHA256(body)
+        )
+    )
+
+---
+
+## Storage layout & migration
+
+- **Writes** are flat: `objects/<hash>`
+- **Reads** (and reindex) also support:
+  - `objects/<hash>/blob|data|content`
+  - `objects/<hash>/<single file>`
+  - `objects/<prefix>/<hash>` (two-level prefix)
+- To **restore** data into a fresh container:
+  1) Mount your objects at `/var/lib/greencoast/objects`
+  2) Call `POST /v1/admin/reindex` (with auth+PoP or enable dev unauth briefly)
+
+---
+
+## Reindex examples
+
+Unauth (dev only):
+
+    curl -X POST https://api-gc.yourdomain/v1/admin/reindex
+
+With bearer + PoP (placeholders):
+
+    curl -X POST https://api-gc.yourdomain/v1/admin/reindex ^
+      -H "Authorization: Bearer <gc2_token>" ^
+      -H "X-GC-Key: p256:<base64raw>" ^
+      -H "X-GC-TS: <unix>" ^
+      -H "X-GC-Proof: <base64sig>"
+
+---
+
+## Hardening checklist (prod)
+
+- Set `GC_REQUIRE_POP=true`, remove dev bypass.
+- Keep access token TTL ≤ 8h; rotate signing key periodically.
+- Static client served with strong CSP (already enabled).
+- Containers run non-root, read-only FS, `no-new-privileges`, `cap_drop: ["ALL"]`.
+- Edge WAF/rate limits; 10 MiB default request cap (tunable).
+- Commit `go.sum`; run `go mod verify` in CI.
+
+---
+
+## GDPR
+
+- Server stores **no PII** (no emails, no IP/UA logs).
+- Timestamps are UTC (or coarse UTC if enabled).
+- `/v1/gdpr/policy` exposes current posture.
+- Roadmap: `/v1/gdpr/export` and `/v1/gdpr/delete` to enumerate/remove blobs signed by a given key.
+
+---
+
+## License
+
+This project is licensed under **The Unlicense**. See `LICENSE` for details.
 
-```bash
-git clone <your repo> greencoast
-cd greencoast
-cp .env.example .env
-docker compose -f docker-compose.dev.yml up --build
-# Health:
-curl -s http://localhost:8080/healthz
-# Put an object (dev mode allows unauthenticated PUT/GET):
-curl -s -X PUT --data-binary @README.md http://localhost:8080/v1/object
-# -> {"ok":true,"hash":"<sha256>",...}
-curl -s http://localhost:8080/v1/object/<sha256> | head

client/app.js

@@ -1,182 +1,605 @@
-import { encryptString, decryptToString, toBlob } from "./crypto.js";
+// GreenCoast client — Trusted-Types safe, 3 visibility modes, PoP auth, x-post,
+// plaintext publishes are anonymous (no Authorization / PoP) when enabled server-side.
 
-const els = {
+const els = {};
-  shardUrl: document.getElementById("shardUrl"),
+function $(id){ return document.getElementById(id); }
-  bearer: document.getElementById("bearer"),
+function on(el, ev, fn){ if (el) el.addEventListener(ev, fn, false); }
-  passphrase: document.getElementById("passphrase"),
-  saveConn: document.getElementById("saveConn"),
-  health: document.getElementById("health"),
-  visibility: document.getElementById("visibility"),
-  title: document.getElementById("title"),
-  body: document.getElementById("body"),
-  publish: document.getElementById("publish"),
-  publishStatus: document.getElementById("publishStatus"),
-  posts: document.getElementById("posts"),
-  discordStart: document.getElementById("discordStart"),
-};
-
-const LS_KEY = "gc_client_config_v1";
-const POSTS_KEY = "gc_posts_index_v1";
-
-const cfg = loadConfig(); applyConfig(); checkHealth(); syncIndex(); sse();
-
-els.saveConn.onclick = async () => {
-  const c = { url: norm(els.shardUrl.value), bearer: els.bearer.value.trim(), passphrase: els.passphrase.value };
-  saveConfig(c); await checkHealth(); await syncIndex(); sse(true);
-};
-
-els.publish.onclick = publish;
-els.discordStart.onclick = discordStart;
-
-function loadConfig(){ try { return JSON.parse(localStorage.getItem(LS_KEY)) ?? {}; } catch { return {}; } }
-function saveConfig(c){ localStorage.setItem(LS_KEY, JSON.stringify(c)); Object.assign(cfg, c); }
-function getPosts(){ try { return JSON.parse(localStorage.getItem(POSTS_KEY)) ?? []; } catch { return []; } }
-function setPosts(v){ localStorage.setItem(POSTS_KEY, JSON.stringify(v)); renderPosts(); }
 function norm(u){ return (u||"").replace(/\/+$/,""); }
-function applyConfig(){ els.shardUrl.value = cfg.url ?? location.origin; els.bearer.value = cfg.bearer ?? ""; els.passphrase.value = cfg.passphrase ?? ""; }
+function flash(msg, ms=1800){ if(!els.flash) return; els.flash.textContent=msg; els.flash.style.display="block"; setTimeout(()=>els.flash.style.display="none", ms); }
+function setText(el, s){ if(el) el.textContent = s; }
+function currentPath(){ const h=location.hash||"#/"; const p=h.replace(/^#/, ""); return p||"/"; }
 
-async function checkHealth() {
+const HAS_SUBTLE = !!(window.isSecureContext && window.crypto && crypto.subtle && crypto.subtle.generateKey);
-  if (!cfg.url) return; els.health.textContent = "Checking…";
+const routes = { "/":"feed", "/privacy":"privacy.html", "/gdpr":"gdpr.html", "/terms":"terms.html" };
-  try { const r = await fetch(cfg.url + "/healthz"); els.health.textContent = r.ok ? "Connected ✔" : `Error: ${r.status}`; }
+
-  catch { els.health.textContent = "Not reachable"; }
+// ---------- Router (Trusted-Types safe text-only render of legal pages) ----------
+function setActiveTab(path){
+  const cur = path in routes ? path : "/";
+  document.querySelectorAll(".tabs a").forEach(a=>{
+    const href = new URL(a.href, location.origin).hash.replace(/^#/, "") || "/";
+    a.classList.toggle("active", href===cur);
+  });
+}
+async function renderRoute(path){
+  setActiveTab(path);
+  const target = routes[path] ?? "feed";
+  if (target === "feed"){ els.page.hidden=true; els.feed.hidden=false; return; }
+  els.feed.hidden=true; els.page.hidden=false;
+  setText(els.pageContent, "Loading…");
+  try{
+    const res = await fetch("./"+target, { cache:"no-store" });
+    const html = await res.text();
+    const body = (html.match(/<body[^>]*>([\s\S]*?)<\/body>/i)?.[1] || html).replace(/<[^>]*>/g,"");
+    setText(els.pageContent, body);
+  }catch{ setText(els.pageContent, "Failed to load page."); }
 }
 
-async function publish() {
+// ---------- Config ----------
-  if (!cfg.url) return msg("Set shard URL first.", true);
+const LS_KEY="gc_client_config_v10", POSTS_KEY="gc_posts_index_v10", KEY_PKCS8="gc_key_pkcs8", KEY_PUB_RAW="gc_key_pub_raw";
-  const title = els.title.value.trim(); const body = els.body.value; const vis = els.visibility.value;
+
+function defaultApiBase() {
+  try { const qs = new URLSearchParams(window.location.search); const qApi = qs.get("api"); if (qApi) return qApi.replace(/\/+$/,""); } catch {}
+  const m=document.querySelector('meta[name="gc-api-base"]'); if(m&&m.content) return m.content.replace(/\/+$/,"");
+  try{
+    const u=new URL(window.location.href); const proto=u.protocol, host=u.hostname, portStr=u.port; const bracketHost=host.includes(":")?`[${host}]`:host;
+    const port = portStr ? parseInt(portStr,10) : null; let apiPort=port;
+    if (port===8082) apiPort=8080; else if (port===9082) apiPort=9080; else if (port) apiPort=Math.max(1,port-2);
+    return apiPort ? `${proto}//${bracketHost}:${apiPort}` : `${proto}//${bracketHost}`;
+  } catch { return window.location.origin.replace(/\/+$/,""); }
+}
+function loadCfg(){ try { return JSON.parse(localStorage.getItem(LS_KEY)) ?? {}; } catch { return {}; } }
+const cfg = loadCfg();
+function saveCfg(c){ localStorage.setItem(LS_KEY, JSON.stringify(Object.assign(cfg,c))); }
+function applyCfg(){
+  els.shardUrl.value = cfg.url ?? defaultApiBase();
+  els.bearer.value = cfg.bearer ?? "";
+  els.passphrase.value = cfg.passphrase ?? "";
+}
+function isAuthorized(){ return !!cfg.bearer; }
+function updateLimitedUI(){
+  const limited = !isAuthorized();
+  if (els.banner) els.banner.hidden = !limited;
+  for (const id of ["visibility","shareVis"]){
+    const sel = $(id); if (!sel) continue;
+    for (const val of ["members","private"]){
+      const opt = [...sel.options].find(o => o.value===val);
+      if (opt) opt.disabled = limited;
+    }
+    if (limited && (sel.value==="members" || sel.value==="private")) sel.value="plaintext";
+  }
+}
+
+// ---------- Crypto helpers ----------
+function b64uEncode(buf){ const bin=Array.from(new Uint8Array(buf)).map(b=>String.fromCharCode(b)).join(""); return btoa(bin).replace(/\+/g,"-").replace(/\//g,"_").replace(/=+$/,""); }
+function b64uDecodeToBytes(s){ s=s.replace(/-/g,"+").replace(/_/g,"/"); while(s.length%4) s+="="; const bin=atob(s); const out=new Uint8Array(bin.length); for(let i=0;i<bin.length;i++) out[i]=bin.charCodeAt(i); return out; }
+async function sha256(bytes){ return new Uint8Array(await crypto.subtle.digest("SHA-256", bytes)); }
+async function sha256Hex(str){ const out=await sha256(new TextEncoder().encode(str)); return Array.from(out).map(b=>b.toString(16).padStart(2,"0")).join(""); }
+
+async function getOrCreateKeyPair(){
+  if (!HAS_SUBTLE) throw new Error("WebCrypto not available");
+  const pkcs8 = sessionStorage.getItem(KEY_PKCS8); const pubRaw = sessionStorage.getItem(KEY_PUB_RAW);
+  if (pkcs8 && pubRaw){
+    try{
+      const priv = await crypto.subtle.importKey("pkcs8", b64uDecodeToBytes(pkcs8), {name:"ECDSA", namedCurve:"P-256"}, true, ["sign"]);
+      const pub  = await crypto.subtle.importKey("raw",   b64uDecodeToBytes(pubRaw), {name:"ECDSA", namedCurve:"P-256"}, true, ["verify"]);
+      return { priv, pub, pkcs8B64u: pkcs8, pubRawB64u: pubRaw };
+    }catch{}
+  }
+  const kp = await crypto.subtle.generateKey({name:"ECDSA", namedCurve:"P-256"}, true, ["sign","verify"]);
+  const pkcs8New = await crypto.subtle.exportKey("pkcs8", kp.privateKey);
+  const pubRawBytes = await crypto.subtle.exportKey("raw", kp.publicKey);
+  const pkcs8B64 = b64uEncode(pkcs8New); const pubRawB64 = b64uEncode(pubRawBytes);
+  sessionStorage.setItem(KEY_PKCS8, pkcs8B64); sessionStorage.setItem(KEY_PUB_RAW, pubRawB64);
+  return { priv: kp.privateKey, pub: kp.publicKey, pkcs8B64u: pkcs8B64, pubRawB64u: pubRawB64 };
+}
+async function deriveMembersPassphrase(saltBytes){
+  const kp = await getOrCreateKeyPair();
+  const seed = await sha256(b64uDecodeToBytes(kp.pkcs8B64u));
+  const cat = new Uint8Array(seed.length + 1 + saltBytes.length);
+  cat.set(seed,0); cat.set(new Uint8Array([1]), seed.length); cat.set(saltBytes, seed.length+1);
+  const out = await sha256(cat);
+  return b64uEncode(out);
+}
+async function deriveAesKey(passphraseB64u, saltBytes){
+  const raw = b64uDecodeToBytes(passphraseB64u);
+  const keyMat = await crypto.subtle.importKey("raw", raw, "PBKDF2", false, ["deriveKey"]);
+  return crypto.subtle.deriveKey(
+    { name:"PBKDF2", salt:saltBytes, iterations:120000, hash:"SHA-256" },
+    keyMat, { name:"AES-GCM", length:256 }, false, ["encrypt","decrypt"]
+  );
+}
+async function aesEncryptString(str, passphraseB64u){
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const key = await deriveAesKey(passphraseB64u, salt);
+  const iv  = crypto.getRandomValues(new Uint8Array(12));
+  const ct  = new Uint8Array(await crypto.subtle.encrypt({name:"AES-GCM", iv}, key, new TextEncoder().encode(str)));
+  return { alg:"aes-256-gcm", iv:b64uEncode(iv), salt:b64uEncode(salt), ct:b64uEncode(ct) };
+}
+async function aesDecryptToString(obj, passphraseB64u){
+  const key = await deriveAesKey(passphraseB64u, b64uDecodeToBytes(obj.salt));
+  const pt  = await crypto.subtle.decrypt({name:"AES-GCM", iv:b64uDecodeToBytes(obj.iv)}, key, b64uDecodeToBytes(obj.ct));
+  return new TextDecoder().decode(pt);
+}
+function makeEnvelope(mode, encObj, meta){ return JSON.stringify({ gc:"2", mode, enc:encObj, meta }); }
+function tryParseJSON(t){ try{ return JSON.parse(t); }catch{ return null; } }
+
+// ---------- Avatar ----------
+function parseGC2(tok){ try{ const p=tok.split("."); if(p.length!==3) return {}; const pl=JSON.parse(atob(p[1].replace(/-/g,"+").replace(/_/g,"/"))); return {sub:pl.sub||"", cnf:pl.cnf||""}; }catch{ return {}; } }
+function identiconPNGFromHex(hex, size=64){
+  const cells=5, cell=Math.floor(size/cells), pad=Math.floor((size-cell*cells)/2);
+  const hexBytes=(h)=>{const u=new Uint8Array(h.length/2); for(let i=0;i<u.length;i++) u[i]=parseInt(h.substr(i*2,2),16); return u;};
+  const b=hexBytes(hex); const hue=b[0]/255*360; const bg=`hsl(${hue},35%,16%)`; const fg=`hsl(${(hue+180)%360},70%,60%)`;
+  const bits=[]; for(const x of b) for(let i=0;i<8;i++) bits.push((x>>i)&1);
+  const c=document.createElement("canvas"); c.width=c.height=size; const g=c.getContext("2d");
+  g.fillStyle=bg; g.fillRect(0,0,size,size); let k=0;
+  for(let y=0;y<cells;y++){ for(let x=0;x<3;x++){ if(bits[k++]===1){ const px=pad+x*cell, py=pad+y*cell;
+    g.fillStyle=fg; g.fillRect(px,py,cell-1,cell-1); const mx=pad+(cells-1-x)*cell; if(cells-1-x!==x) g.fillRect(mx,py,cell-1,cell-1); } } }
+  return c.toDataURL("image/png");
+}
+async function renderAvatar(){
+  if (!els.avatar) return;
+  let seed=null, label="(pseudonymous)";
+  if (cfg.bearer){ const p=parseGC2(cfg.bearer); seed=p.cnf||p.sub||null; if(p.sub) label=p.sub; }
+  if (!seed){ els.avatar.removeAttribute("src"); setText(els.fp,"(pseudonymous)"); return; }
+  const hex = await sha256Hex(seed);
+  els.avatar.onerror = ()=>{ els.avatar.removeAttribute("src"); setText(els.fp,"(pseudonymous)"); };
+  els.avatar.src=identiconPNGFromHex(hex, 64);
+  setText(els.fp, label+" (pseudonymous)");
+}
+
+// ---------- Auth / PoP ----------
+async function requireChallengeAlive(base) {
   try {
-    let blob, enc=false;
+    const r = await fetch(base + "/v1/auth/key/challenge", { method: "POST" });
-    if (vis === "private") {
+    if (r.status === 404) {
-      if (!cfg.passphrase) return msg("Set a passphrase for private posts.", true);
+      alert(
-      const payload = await encryptString(JSON.stringify({ title, body }), cfg.passphrase);
+        "Shard URL looks wrong: /v1/auth/key/challenge not found.\n\n" +
-      blob = toBlob(payload); enc=true;
+        "Current base:\n" + base + "\n\n" +
-    } else { blob = toBlob(JSON.stringify({ title, body })); }
+        "Set it to your API host (e.g. https://api-gc.fullmooncyberworks.com) and Save."
-    const headers = { "Content-Type":"application/octet-stream" };
+      );
-    if (cfg.bearer) headers["Authorization"] = "Bearer " + cfg.bearer;
+      return false;
-    if (enc) headers["X-GC-Private"] = "1";
+    }
-    const r = await fetch(cfg.url + "/v1/object", { method:"PUT", headers, body: blob });
+    return r.ok;
+  } catch {
+    alert("Cannot reach shard at: " + base);
+    return false;
+  }
+}
+
+async function deviceKeySignIn(){
+  if (!HAS_SUBTLE) { alert("Device keys not supported. Use Discord or a modern browser."); return; }
+  const base = cfg.url || defaultApiBase(); if (!base){ alert("Set shard URL first."); return; }
+  if (!(await requireChallengeAlive(base))) return;
+  flash("Signing in…");
+  try{
+    const { priv, pubRawB64u } = await getOrCreateKeyPair();
+    const rc = await fetch(base + "/v1/auth/key/challenge", { method:"POST" });
+    if (!rc.ok) throw new Error("challenge "+rc.status);
+    const cj = await rc.json();
+    const msg = new TextEncoder().encode("key-verify\n"+cj.nonce);
+    const sig = await crypto.subtle.sign({name:"ECDSA", hash:"SHA-256"}, priv, msg);
+    const body = JSON.stringify({ nonce:cj.nonce, alg:"p256", pub:pubRawB64u, sig:b64uEncode(sig) });
+    const rv = await fetch(base + "/v1/auth/key/verify", { method:"POST", headers:{"Content-Type":"application/json"}, body });
+    if (!rv.ok) throw new Error("verify "+rv.status);
+    const vj = await rv.json();
+    saveCfg({ bearer: vj.bearer }); applyCfg(); updateLimitedUI();
+    await renderAvatar(); await checkHealth(); await syncIndex(); sse(true); flash("Signed in");
+  }catch(e){ console.error(e); alert("Sign-in error: "+(e?.message||e)); }
+}
+
+async function signPoPHeaders(method, pathOnly, bodyBytes){
+  if (!HAS_SUBTLE) return {};
+  const pubRaw = sessionStorage.getItem(KEY_PUB_RAW); const pkcs8 = sessionStorage.getItem(KEY_PKCS8);
+  if (!pubRaw || !pkcs8) return {};
+  const priv = await crypto.subtle.importKey("pkcs8", b64uDecodeToBytes(pkcs8), {name:"ECDSA", namedCurve:"P-256"}, false, ["sign"]);
+  const bodyHash = new Uint8Array(await crypto.subtle.digest("SHA-256", bodyBytes || new Uint8Array()));
+  const hex = Array.from(bodyHash).map(b=>b.toString(16).padStart(2,"0")).join("");
+  const ts = Math.floor(Date.now()/1000).toString();
+  const msg = new TextEncoder().encode(method.toUpperCase()+"\n"+pathOnly+"\n"+ts+"\n"+hex);
+  const sig = await crypto.subtle.sign({name:"ECDSA", hash:"SHA-256"}, priv, msg);
+  return { "X-GC-Key":"p256:"+pubRaw, "X-GC-TS":ts, "X-GC-Proof":b64uEncode(sig) };
+}
+async function fetchWithPoP(url, opts){
+  const u = new URL(url); const path = u.pathname; const method = (opts?.method||"GET").toUpperCase();
+  const bodyBuf = opts?.body instanceof Blob ? new Uint8Array(await opts.body.arrayBuffer())
+                 : (opts?.body instanceof ArrayBuffer ? new Uint8Array(opts.body) : new Uint8Array());
+  const pop = await signPoPHeaders(method, path, bodyBuf);
+  const headers = new Headers(opts?.headers||{});
+  if (cfg.bearer) headers.set("Authorization", "Bearer "+cfg.bearer);
+  for (const [k,v] of Object.entries(pop)) headers.set(k,v);
+  return fetch(url, { ...(opts||{}), headers });
+}
+// Anonymous fetch: strip any auth/PoP headers completely (for plaintext writes)
+function stripAuthHeaders(h){ h.delete("Authorization"); h.delete("X-GC-Key"); h.delete("X-GC-TS"); h.delete("X-GC-Proof"); return h; }
+async function fetchAnon(url, opts){
+  const headers = new Headers(opts?.headers || {});
+  return fetch(url, { ...(opts||{}), headers: stripAuthHeaders(headers) });
+}
+
+// ---------- Leak detection ----------
+const SECRET_PATTERNS = [
+  /\b(passphrase|password|secret|gc[-_ ]?pass|shared[-_ ]?key)\s*[:=]\s*[^\s]{8,}/i,
+  /\b(ASIA|AKIA|AIza)[0-9A-Za-z_\-]{10,}/,
+  /\b[A-Za-z0-9+/_-]{32,}={0,2}\b/,
+  /\b[0-9a-f]{64,}\b/i,
+  /-----BEGIN [A-Z ]{5,}-----[\s\S]+?-----END [A-Z ]{5,}-----/
+];
+function containsSecret(text, passphrase){
+  if (!text) return false;
+  if (passphrase && passphrase.length>=6 && text.includes(passphrase)) return true;
+  return SECRET_PATTERNS.some(rx => rx.test(text));
+}
+
+// ---------- X-post helpers ----------
+const TRACKING_PARAMS = [/^utm_/i,/^gclid$/i,/^fbclid$/i,/^msclkid$/i,/^mc_(eid|cid)$/i,/^vero_id$/i,/^oly_(anon|enc)_id$/i,/^_hs(enc|mi|mi)/i,/^s?cid$/i,/^igshid$/i,/^ttclid$/i,/^spm$/i,/^ref$/i,/^ref_src$/i,/^ref_url$/i];
+function sanitizeUrl(input){
+  try{
+    const u = new URL(input.trim());
+    for (const [k] of u.searchParams){ if (TRACKING_PARAMS.some(rx=>rx.test(k))) u.searchParams.delete(k); }
+    u.hash = "";
+    return u.toString();
+  }catch{ return ""; }
+}
+function shortHost(h){ try{ const p=h.split("."); return p.length>2 ? p.slice(-2).join(".") : h; }catch{ return h; } }
+function renderXCard(container, cleanUrl, note){
+  container.replaceChildren();
+  if (!cleanUrl){ const m=document.createElement("div"); m.className="xmeta"; m.textContent="Enter a valid URL."; container.appendChild(m); return; }
+  const u = new URL(cleanUrl);
+  const row = document.createElement("div"); row.className="xrow";
+  const pill = document.createElement("span"); pill.className="xpill"; pill.textContent=shortHost(u.hostname);
+  const title = document.createElement("span"); title.className="xtitle"; title.textContent=note || `${shortHost(u.hostname)} link`;
+  row.appendChild(pill); row.appendChild(title);
+
+  const meta = document.createElement("div"); meta.className="xmeta"; meta.textContent=(u.pathname||"/")+(u.search||"");
+
+  const btn = document.createElement("div"); btn.className="xbtn";
+  const a = document.createElement("a"); a.href=cleanUrl; a.target="_blank"; a.rel="noreferrer noopener"; a.referrerPolicy="no-referrer"; a.textContent="Open privately ↗";
+  btn.appendChild(a);
+
+  container.appendChild(row); container.appendChild(meta); container.appendChild(btn);
+}
+
+// ---------- Compose / Publish ----------
+function msg(t, err=false){ setText(els.publishStatus, t); els.publishStatus.style.color = err ? "#ff6b6b" : "#8b949e"; }
+
+async function publish(){
+  const base = cfg.url || defaultApiBase(); if (!base) return msg("Set shard URL first.", true);
+
+  const mode = els.visibility.value; // plaintext | members | private
+  const title = els.title.value.trim();
+  const body  = els.body.value;
+
+  if ((mode==="members"||mode==="private") && !isAuthorized()){ msg("Authorize your device to publish encrypted posts.", true); return; }
+
+  const currentPass = els.passphrase.value.trim();
+  if (containsSecret(body, currentPass)){ msg("Blocked: content appears to include a passkey/secret.", true); return; }
+
+  try{
+    let blob, headers={"Content-Type":"application/octet-stream"}, enc=false;
+
+    if (mode==="plaintext"){
+      blob = new Blob([JSON.stringify({ title, body, type:"plaintext" })], {type:"application/json"});
+    } else if (mode==="members"){
+      const salt = crypto.getRandomValues(new Uint8Array(16));
+      const pp = await deriveMembersPassphrase(salt);
+      const encObj = await aesEncryptString(JSON.stringify({ title, body, type:"members" }), pp);
+      const env = makeEnvelope("members", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
+      blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
+    } else if (mode==="private"){
+      if (!currentPass) return msg("Set a passphrase for Private-Encrypted posts.", true);
+      const pp = b64uEncode(new TextEncoder().encode(currentPass));
+      const encObj = await aesEncryptString(JSON.stringify({ title, body, type:"private" }), pp);
+      const env = makeEnvelope("private", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
+      blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
+    }
+
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone; if (tz) headers["X-GC-TZ"]=tz;
+
+    const url = base + "/v1/object";
+    let r;
+    if (mode === "plaintext") {
+      // truly anonymous write (requires allow_anon_plaintext on shard)
+      r = await fetchAnon(url, { method:"PUT", headers, body: blob });
+    } else {
+      r = await fetchWithPoP(url, { method:"PUT", headers, body: blob });
+    }
     if (!r.ok) throw new Error(await r.text());
     const j = await r.json();
+
     const posts = getPosts();
-    posts.unshift({ hash:j.hash, title: title || "(untitled)", bytes:j.bytes, ts:j.stored_at, enc });
+    posts.unshift({ hash:j.hash, title: title || (enc?"(encrypted)":"(untitled)"), bytes:j.bytes, ts:j.stored_at, enc, mode, author:j.author||null, tz:j.creator_tz||null });
     setPosts(posts);
-    els.body.value = ""; msg(`Published ${enc?"private":"public"} post. Hash: ${j.hash}`);
+    els.body.value="";
-  } catch(e){ msg("Publish failed: " + (e?.message||e), true); }
+    msg(`Published ${mode}. Hash: ${j.hash}`);
+  }catch(e){ msg("Publish failed: "+(e?.message||e), true); }
 }
 
-function msg(t, err=false){ els.publishStatus.textContent=t; els.publishStatus.style.color = err ? "#ff6b6b" : "#8b949e"; }
+async function publishShare(){
+  const base = cfg.url || defaultApiBase(); if (!base) return alert("Set shard URL first.");
+  const clean = sanitizeUrl(els.shareUrl.value); if (!clean) return alert("Enter a valid URL.");
 
-async function syncIndex() {
+  const mode = els.shareVis.value;
-  if (!cfg.url) return;
+  const note = els.shareNote.value || "";
-  try {
+
-    const headers = {}; if (cfg.bearer) headers["Authorization"] = "Bearer " + cfg.bearer;
+  if ((mode==="members"||mode==="private") && !isAuthorized()){ alert("Authorize your device to publish encrypted links."); return; }
-    const r = await fetch(cfg.url + "/v1/index", { headers });
+  if (containsSecret(note, els.passphrase.value.trim())){ alert("Blocked: content appears to include a passkey/secret."); return; }
+
+  try{
+    let blob, headers={"Content-Type":"application/octet-stream"}, enc=false;
+
+    if (mode==="plaintext"){
+      blob = new Blob([JSON.stringify({ type:"xpost", url: clean, note, created_at:new Date().toISOString() })], {type:"application/json"});
+    } else if (mode==="members"){
+      const salt = crypto.getRandomValues(new Uint8Array(16));
+      const pp = await deriveMembersPassphrase(salt);
+      const encObj = await aesEncryptString(JSON.stringify({ type:"xpost", url: clean, note, created_at:new Date().toISOString() }), pp);
+      const env = makeEnvelope("members", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
+      blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
+    } else {
+      const pass = els.passphrase.value.trim(); if (!pass) return alert("Set a passphrase for Private-Encrypted links.");
+      const pp = b64uEncode(new TextEncoder().encode(pass));
+      const encObj = await aesEncryptString(JSON.stringify({ type:"xpost", url: clean, note, created_at:new Date().toISOString() }), pp);
+      const env = makeEnvelope("private", encObj, { tz: Intl.DateTimeFormat().resolvedOptions().timeZone || "" });
+      blob = new Blob([env], {type:"application/json"}); headers["X-GC-Private"]="1"; enc=true;
+    }
+
+    const tz = Intl.DateTimeFormat().resolvedOptions().timeZone; if (tz) headers["X-GC-TZ"]=tz;
+
+    const url = base + "/v1/object";
+    let r;
+    if (mode === "plaintext") {
+      r = await fetchAnon(url, { method:"PUT", headers, body: blob });
+    } else {
+      r = await fetchWithPoP(url, { method:"PUT", headers, body: blob });
+    }
+    if (!r.ok) throw new Error(await r.text());
+    const j = await r.json();
+
+    const posts = getPosts();
+    posts.unshift({ hash:j.hash, title:"(link)", bytes:j.bytes, ts:j.stored_at, enc, mode, author:j.author||null, tz:j.creator_tz||null });
+    setPosts(posts);
+    els.shareUrl.value=""; els.shareNote.value="";
+    renderXCard(els.shareCard, "", "");
+    flash("Link published");
+  }catch(e){ alert("Publish failed: "+(e?.message||e)); }
+}
+
+// ---------- View / Decrypt ----------
+async function viewPost(p, pre){
+  const base = cfg.url || defaultApiBase(); pre.textContent="Loading…";
+  try{
+    const r = await fetch(base + "/v1/object/"+p.hash);
+    if (!r.ok) throw new Error("fetch failed "+r.status);
+    const buf = new Uint8Array(await r.arrayBuffer());
+    const text = new TextDecoder().decode(buf);
+
+    const env = tryParseJSON(text);
+    if (env && env.gc==="2" && env.enc && env.mode){
+      const enc = env.enc; let pt;
+      if (env.mode==="members"){
+        if (!HAS_SUBTLE) throw new Error("Cannot decrypt on this browser.");
+        const pp = await deriveMembersPassphrase(b64uDecodeToBytes(enc.salt));
+        pt = await aesDecryptToString(enc, pp);
+      } else if (env.mode==="private"){
+        const pass = els.passphrase.value.trim(); if (!pass) throw new Error("Passphrase required");
+        const pp = b64uEncode(new TextEncoder().encode(pass));
+        pt = await aesDecryptToString(enc, pp);
+      } else { throw new Error("Unknown mode"); }
+
+      const j = tryParseJSON(pt);
+      if (j && j.type==="xpost" && j.url){
+        const wrap = pre.parentElement; const card = document.createElement("div"); card.className="xcard";
+        renderXCard(card, sanitizeUrl(j.url), j.note||""); wrap.replaceChild(card, pre); return;
+      }
+      pre.textContent = (j?.title?`# ${j.title}\n\n`:"") + (j?.body ?? pt);
+      return;
+    }
+
+    const j = tryParseJSON(text);
+    if (j){
+      if (j.type==="xpost" && j.url){
+        const wrap = pre.parentElement; const card = document.createElement("div"); card.className="xcard";
+        renderXCard(card, sanitizeUrl(j.url), j.note||""); wrap.replaceChild(card, pre); return;
+      }
+      pre.textContent = (j.title?`# ${j.title}\n\n`:"") + (j.body ?? text);
+      return;
+    }
+
+    pre.textContent = text;
+  }catch(e){ pre.textContent="Error: "+(e?.message||e); }
+}
+
+async function saveBlob(p){
+  const base = cfg.url || defaultApiBase();
+  const r = await fetch(base + "/v1/object/"+p.hash);
+  if (!r.ok) return alert("download failed "+r.status);
+  const b = await r.blob(); const a=document.createElement("a"); a.href=URL.createObjectURL(b);
+  a.download=p.hash+(p.enc?".gcenc":".json"); a.click(); URL.revokeObjectURL(a.href);
+}
+async function delServer(p){
+  const base = cfg.url || defaultApiBase();
+  if (!confirm("Delete blob from server by hash?")) return;
+  const r = await fetchWithPoP(base + "/v1/object/"+p.hash, { method:"DELETE" });
+  if (!r.ok) return alert("delete failed "+r.status);
+  setPosts(getPosts().filter(x=>x.hash!==p.hash));
+}
+
+// ---------- Index / SSE / Health ----------
+function getPosts(){ try { return JSON.parse(localStorage.getItem(POSTS_KEY)) ?? []; } catch { return []; } }
+function setPosts(v){ localStorage.setItem(POSTS_KEY, JSON.stringify(v)); renderPosts(); }
+async function syncIndex(){
+  const base = cfg.url || defaultApiBase(); if (!base) return;
+  try{
+    const r = await fetch(base + "/v1/index");
     if (!r.ok) throw new Error("index fetch failed");
     const entries = await r.json();
-    setPosts(entries.map(e => ({ hash:e.hash, title:"(title unknown — fetch)", bytes:e.bytes, ts:e.stored_at, enc:e.private })));
+    setPosts(entries.map(e=>({
-  } catch(e){ console.warn("index sync failed", e); }
+      hash:e.hash, title:"(title unknown — fetch)", bytes:e.bytes, ts:e.stored_at,
+      enc:e.private, mode: e.private ? "encrypted" : "plaintext",
+      author:e.author||null, tz:e.creator_tz||null
+    })));
+  }catch(e){ console.warn("index sync failed", e); }
 }
-
 let sseCtrl;
-function sse(){
+function sse(reset=false){
-  if (!cfg.url) return;
+  const base = cfg.url || defaultApiBase(); if (!base) return;
-  if (sseCtrl) { sseCtrl.abort(); sseCtrl = undefined; }
+  if (sseCtrl){ sseCtrl.abort(); sseCtrl=undefined; if(!reset) return; }
   sseCtrl = new AbortController();
-  const url = cfg.url + "/v1/index/stream";
+  fetch(base + "/v1/index/stream", { signal:sseCtrl.signal }).then(async resp=>{
-  const headers = {}; if (cfg.bearer) headers["Authorization"] = "Bearer " + cfg.bearer;
-  fetch(url, { headers, signal: sseCtrl.signal }).then(async resp => {
     if (!resp.ok) return;
-    const reader = resp.body.getReader(); const decoder = new TextDecoder();
+    const reader = resp.body.getReader(); const dec = new TextDecoder(); let buf="";
-    let buf = "";
+    while(true){ const {value,done}=await reader.read(); if(done) break;
-    while (true) {
+      buf += dec.decode(value,{stream:true});
-      const { value, done } = await reader.read(); if (done) break;
+      let i; while((i=buf.indexOf("\n\n"))>=0){
-      buf += decoder.decode(value, { stream:true });
+        const chunk=buf.slice(0,i); buf=buf.slice(i+2);
-      let idx;
+        if (chunk.startsWith("data: ")){
-      while ((idx = buf.indexOf("\n\n")) >= 0) {
+          try{
-        const chunk = buf.slice(0, idx); buf = buf.slice(idx+2);
-        if (chunk.startsWith("data: ")) {
-          try {
             const ev = JSON.parse(chunk.slice(6));
-            if (ev.event === "put") {
+            if (ev.event==="put"){
-              const e = ev.data;
+              const e=ev.data; const posts=getPosts();
-              const posts = getPosts();
+              if (!posts.find(p=>p.hash===e.hash)){
-              if (!posts.find(p => p.hash === e.hash)) {
+                posts.unshift({hash:e.hash,title:"(title unknown — fetch)",bytes:e.bytes,ts:e.stored_at,enc:e.private,mode:e.private?"encrypted":"plaintext",author:e.author||null,tz:e.creator_tz||null});
-                posts.unshift({ hash:e.hash, title:"(title unknown — fetch)", bytes:e.bytes, ts:e.stored_at, enc:e.private });
                 setPosts(posts);
               }
-            } else if (ev.event === "delete") {
+            } else if (ev.event==="delete"){
-              const h = ev.data.hash; setPosts(getPosts().filter(p => p.hash !== h));
+              const h=ev.data.hash; setPosts(getPosts().filter(x=>x.hash!==h));
             }
-          } catch {}
+          }catch{}
         }
       }
     }
   }).catch(()=>{});
 }
-
+async function checkHealth(){
-async function viewPost(p, pre) {
+  const base = cfg.url || defaultApiBase();
-  pre.textContent = "Loading…";
+  if (!base) { setText(els.health,"Set URL"); return; }
-  try {
+  setText(els.health,"Checking…");
-    const headers = {}; if (cfg.bearer) headers["Authorization"] = "Bearer " + cfg.bearer;
+  try { const r = await fetch(base + "/healthz"); setText(els.health, r.ok ? "Connected ✔" : `Error: ${r.status}`); }
-    const r = await fetch(cfg.url + "/v1/object/" + p.hash, { headers });
+  catch { setText(els.health,"Not reachable"); }
-    if (!r.ok) throw new Error("fetch failed " + r.status);
-    const buf = new Uint8Array(await r.arrayBuffer());
-    let text;
-    if (p.enc) {
-      if (!cfg.passphrase) throw new Error("passphrase required");
-      text = await decryptToString(buf, cfg.passphrase);
-    } else { text = new TextDecoder().decode(buf); }
-    try {
-      const j = JSON.parse(text);
-      pre.textContent = (j.title ? `# ${j.title}\n\n` : "") + (j.body ?? text);
-    } catch { pre.textContent = text; }
-  } catch (e) { pre.textContent = "Error: " + (e?.message || e); }
-}
-
-async function saveBlob(p) {
-  const headers = {}; if (cfg.bearer) headers["Authorization"] = "Bearer " + cfg.bearer;
-  const r = await fetch(cfg.url + "/v1/object/" + p.hash, { headers });
-  if (!r.ok) return alert("download failed " + r.status);
-  const b = await r.blob();
-  const a = document.createElement("a"); a.href = URL.createObjectURL(b);
-  a.download = p.hash + (p.enc ? ".gcenc" : ".json"); a.click(); URL.revokeObjectURL(a.href);
-}
-
-async function delServer(p) {
-  const headers = {}; if (cfg.bearer) headers["Authorization"] = "Bearer " + cfg.bearer;
-  if (!confirm("Delete blob from server by hash?")) return;
-  const r = await fetch(cfg.url + "/v1/object/" + p.hash, { method:"DELETE", headers });
-  if (!r.ok) return alert("delete failed " + r.status);
-  setPosts(getPosts().filter(x=>x.hash!==p.hash));
-}
-
-async function discordStart() {
-  if (!cfg.url) { alert("Set shard URL first."); return; }
-  const r = await fetch(cfg.url + "/v1/auth/discord/start", { headers: { "X-GC-3P-Assent":"1" }});
-  if (!r.ok) { alert("Discord SSO not available"); return; }
-  const j = await r.json();
-  location.href = j.url;
 }
 
+// ---------- Render posts (no innerHTML) ----------
 function renderPosts() {
-  const posts = getPosts(); els.posts.innerHTML = "";
+  const posts = getPosts();
+  const root = els.posts;
+  if (!root) return;
+  while (root.firstChild) root.removeChild(root.firstChild);
+
   for (const p of posts) {
-    const div = document.createElement("div"); div.className = "post";
+    const wrap = document.createElement("div");
-    const badge = p.enc ? `<span class="badge">private</span>` : `<span class="badge">public</span>`;
+    wrap.className = "post";
-    div.innerHTML = `
+
-      <div class="meta"><code>${p.hash.slice(0,10)}…</code> · ${p.bytes} bytes · ${p.ts} ${badge}</div>
+    const meta = document.createElement("div");
-      <div class="actions">
+    meta.className = "meta";
-        <button data-act="view">View</button>
+
-        <button data-act="save">Save blob</button>
+    const codeEl = document.createElement("code");
-        <button data-act="delete">Delete (server)</button>
+    codeEl.textContent = `${p.hash.slice(0, 10)}…`;
-        <button data-act="remove">Remove (local)</button>
+    meta.appendChild(codeEl);
-      </div>
+
-      <pre class="content" style="white-space:pre-wrap;margin-top:.5rem;"></pre>`;
+    const metaText = [
-    const pre = div.querySelector(".content");
+      ` · ${p.bytes} bytes`,
-    div.querySelector('[data-act="view"]').onclick = () => viewPost(p, pre);
+      ` · ${p.ts}`,
-    div.querySelector('[data-act="save"]').onclick = () => saveBlob(p);
+      p.tz ? ` · tz:${p.tz}` : "",
-    div.querySelector('[data-act="delete"]').onclick = () => delServer(p);
+      p.author ? ` · by ${p.author.slice(0, 8)}…` : "",
-    div.querySelector('[data-act="remove"]').onclick = () => { setPosts(getPosts().filter(x=>x.hash!==p.hash)); };
+      " "
-    els.posts.appendChild(div);
+    ].join("");
+    meta.appendChild(document.createTextNode(metaText));
+
+    const badge = document.createElement("span");
+    badge.className = "badge";
+    badge.textContent = p.enc ? (p.mode==="private"?"private":"encrypted") : "plaintext";
+    meta.appendChild(badge);
+
+    wrap.appendChild(meta);
+
+    const actions = document.createElement("div");
+    actions.className = "actions";
+
+    const mkBtn = (label, onClick) => {
+      const b = document.createElement("button");
+      b.type = "button";
+      b.textContent = label;
+      b.addEventListener("click", onClick);
+      return b;
+    };
+
+    const pre = document.createElement("pre");
+    pre.className = "content";
+    pre.style.whiteSpace = "pre-wrap";
+    pre.style.marginTop = ".5rem";
+
+    actions.appendChild(mkBtn("View", () => viewPost(p, pre)));
+    actions.appendChild(mkBtn("Save blob", () => saveBlob(p)));
+    actions.appendChild(mkBtn("Delete (server)", () => delServer(p)));
+    actions.appendChild(mkBtn("Remove (local)", () => {
+      setPosts(getPosts().filter((x) => x.hash !== p.hash));
+    }));
+
+    wrap.appendChild(actions);
+
+    const contentWrap = document.createElement("div");
+    contentWrap.className = "content-wrap";
+    contentWrap.appendChild(pre);
+    wrap.appendChild(contentWrap);
+
+    root.appendChild(wrap);
   }
 }
+
+// ---------- Save/Init ----------
+async function onSaveConn(){
+  const c = { url: norm(els.shardUrl.value || defaultApiBase()), bearer: els.bearer.value.trim(), passphrase: els.passphrase.value };
+  saveCfg(c); flash("Saved");
+  updateLimitedUI(); await checkHealth(); await syncIndex(); sse(true); await renderAvatar();
+}
+async function panicWipe(){
+  flash("Wiping local state…");
+  try { const base = cfg.url || defaultApiBase(); if (base) await fetch(base + "/v1/session/clear", { method:"POST" }); } catch {}
+  localStorage.clear(); sessionStorage.clear(); caches?.keys?.().then(keys => keys.forEach(k => caches.delete(k)));
+  flash("Cleared — reloading"); setTimeout(()=>location.reload(), 300);
+}
+async function discordStart(){
+  const base = cfg.url || defaultApiBase(); if (!base){ alert("Set shard URL first."); return; }
+  const r = await fetch(base + "/v1/auth/discord/start", { headers: { "X-GC-3P-Assent":"1" }});
+  if (!r.ok){ alert("Discord SSO not available"); return; }
+  const j = await r.json(); location.href = j.url;
+}
+
+// ---------- Boot ----------
+window.addEventListener("DOMContentLoaded", () => {
+  Object.assign(els, {
+    shardUrl:$("shardUrl"), bearer:$("bearer"), passphrase:$("passphrase"),
+    saveConn:$("saveConn"), health:$("health"), visibility:$("visibility"),
+    title:$("title"), body:$("body"), publish:$("publish"), publishStatus:$("publishStatus"),
+    posts:$("posts"), discordStart:$("discordStart"), signIn:$("signIn"), panic:$("panic"),
+    avatar:$("avatar"), fp:$("fp"), flash:$("flash"), banner:$("banner"),
+    feed:$("feed"), page:$("page"), pageContent:$("pageContent"),
+    shareUrl:$("shareUrl"), shareNote:$("shareNote"), shareVis:$("shareVis"),
+    sharePreview:$("sharePreview"), sharePublish:$("sharePublish"), shareCard:$("shareCard")
+  });
+
+  on(els.saveConn, "click", onSaveConn);
+  on(els.publish, "click", publish);
+  on(els.discordStart, "click", discordStart);
+  on(els.signIn, "click", deviceKeySignIn);
+  on(els.panic, "click", panicWipe);
+
+  on(els.sharePreview, "click", ()=>renderXCard(els.shareCard, sanitizeUrl(els.shareUrl.value), els.shareNote.value));
+  on(els.sharePublish, "click", publishShare);
+
+  window.addEventListener('hashchange', ()=>renderRoute(currentPath()));
+
+  if (!HAS_SUBTLE) {
+    const cap = $("capWarn");
+    if (cap){
+      cap.hidden=false;
+      cap.textContent = "This browser lacks secure WebCrypto. Device-key and members-encrypted posts require a modern browser over HTTPS. Discord sign-in remains available.";
+    }
+    if (els.signIn){ els.signIn.disabled = true; els.signIn.textContent = "Device key not supported"; }
+  }
+
+  applyCfg(); updateLimitedUI();
+  (async () => { await checkHealth(); await syncIndex(); sse(); await renderAvatar(); })();
+  renderRoute(currentPath());
+  flash("GC client loaded");
+});

client/auth_callback.html

@@ -1,43 +1,20 @@
 <!doctype html>
-<html>
+<meta charset="utf-8">
-<head>
+<title>Signing you in…</title>
-  <meta charset="utf-8"/>
+<script>
-  <title>GreenCoast — Auth Callback</title>
+(function(){
-  <meta name="viewport" content="width=device-width, initial-scale=1"/>
+  const hash = new URLSearchParams(location.hash.slice(1));
-  <style>
+  const bearer = hash.get("bearer");
-    body { font-family: system-ui, -apple-system, Segoe UI, Roboto, Arial; background:#0b1117; color:#e6edf3; display:flex; align-items:center; justify-content:center; height:100vh; }
+  const next = hash.get("next") || "/";
-    .card { background:#0f1621; padding:1rem 1.2rem; border-radius:14px; max-width:560px; }
+  try {
-    .muted{ color:#8b949e; }
+    // Prefer sessionStorage; keep localStorage for backward compatibility
-  </style>
+    if (bearer) sessionStorage.setItem("gc_bearer", bearer);
-</head>
+    const k = "gc_client_config_v1";
-<body>
+    const cfg = JSON.parse(localStorage.getItem(k) || "{}");
-  <div class="card">
+    if (bearer) cfg.bearer = bearer;
-    <h3>Signing you in…</h3>
+    localStorage.setItem(k, JSON.stringify(cfg));
-    <div id="msg" class="muted">Please wait.</div>
+  } catch {}
-  </div>
+  history.replaceState(null, "", next);
-<script type="module">
+  location.href = next;
-  const params = new URLSearchParams(location.search);
+})();
-  const code = params.get("code");
-  const origin = location.origin; // shard and client served together
-  const msg = (t)=>document.getElementById("msg").textContent = t;
-
-  async function run() {
-    if (!code) { msg("Missing 'code' parameter."); return; }
-    try {
-      const r = await fetch(origin + "/v1/auth/discord/callback?assent=1&code=" + encodeURIComponent(code));
-      if (!r.ok) { msg("Exchange failed: " + r.status); return; }
-      const j = await r.json();
-      const key = "gc_client_config_v1";
-      const cfg = JSON.parse(localStorage.getItem(key) || "{}");
-      cfg.bearer = j.token;
-      localStorage.setItem(key, JSON.stringify(cfg));
-      msg("Success. Redirecting…");
-      setTimeout(()=>location.href="/", 800);
-    } catch(e) {
-      msg("Error: " + (e?.message || e));
-    }
-  }
-  run();
 </script>
-</body>
-</html>

client/avatar.js

@@ -0,0 +1,44 @@
+// Deterministic, local-only avatars. No network calls.
+export function avatarDataURL(seed, size = 40) {
+  // Hash seed → bytes
+  const h = sha256(seed);
+  // Colors from bytes
+  const hue = h[0] % 360;
+  const bg = `hsl(${(h[1]*3)%360} 25% 14%)`;
+  const fg = `hsl(${hue} 70% 60%)`;
+
+  // 5x5 grid mirrored; draw squares where bits set
+  const cells = 5, scale = Math.floor(size / cells);
+  let rects = "";
+  for (let y = 0; y < cells; y++) {
+    for (let x = 0; x < Math.ceil(cells/2); x++) {
+      const bit = (h[(y*3 + x) % h.length] >> (y % 5)) & 1;
+      if (bit) {
+        const xL = x*scale, xR = (cells-1-x)*scale, yP = y*scale;
+        rects += `<rect x="${xL}" y="${yP}" width="${scale}" height="${scale}" rx="2" ry="2" fill="${fg}"/>`;
+        if (x !== cells-1-x) {
+          rects += `<rect x="${xR}" y="${yP}" width="${scale}" height="${scale}" rx="2" ry="2" fill="${fg}"/>`;
+        }
+      }
+    }
+  }
+  const svg = `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${cells*scale} ${cells*scale}">
+    <rect width="100%" height="100%" fill="${bg}"/>${rects}
+  </svg>`;
+  return "data:image/svg+xml;base64," + btoa(unescape(encodeURIComponent(svg)));
+}
+
+function sha256(s) {
+  // Simple synchronous hash-ish bytes from string (non-cryptographic; fine for visuals)
+  let h1 = 0x6a09e667, h2 = 0xbb67ae85;
+  for (let i=0;i<s.length;i++) {
+    const c = s.charCodeAt(i);
+    h1 = (h1 ^ c) * 0x45d9f3b + ((h1<<7) | (h1>>>25));
+    h2 = (h2 ^ (c<<1)) * 0x27d4eb2d + ((h2<<9) | (h2>>>23));
+  }
+  const out = new Uint8Array(32);
+  for (let i=0;i<32;i++){
+    out[i] = (h1 >> (i%24)) ^ (h2 >> ((i*3)%24)) ^ (i*31);
+  }
+  return out;
+}

client/gdpr.html

@@ -0,0 +1,38 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <title>GDPR Notice — GreenCoast</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1"/>
+  <link rel="stylesheet" href="./styles.css"/>
+</head>
+<body class="container">
+  <h1>GDPR Notice</h1>
+  <p class="muted">Effective: 2025-08-22</p>
+
+  <h2>Controller</h2>
+  <p>The operator of this shard acts as data controller. Contact: <em>dsapelli@yahoo.com</em>.</p>
+
+  <h2>Lawful bases</h2>
+  <ul>
+    <li><strong>Public posts:</strong> performance of service you request.</li>
+    <li><strong>Private posts:</strong> performance of service; encryption keys never leave your device.</li>
+    <li><strong>SSO (optional):</strong> your consent with the chosen provider.</li>
+  </ul>
+
+  <h2>Minimization & storage</h2>
+  <p>No user profile, no behavioral analytics. Objects are stored by content hash; server logs are minimized and scrubbed of IPs/UA where feasible.</p>
+
+  <h2>International transfers</h2>
+  <p>Content may be hosted where you deploy the shard. Using third-party SSO may transfer data to those providers’ regions.</p>
+
+  <h2>Data subject rights</h2>
+  <p>Access/erasure/rectification: We do not keep a server-side identity. Uploaders can delete objects by hash if they still possess authorization. Encrypted content cannot be decrypted server-side.</p>
+
+  <h2>Complaints</h2>
+  <p>You may lodge a complaint with your local supervisory authority.</p>
+
+  <p class="muted small">This document is informational and not legal advice.</p>
+  <p><a href="./index.html">Back</a></p>
+</body>
+</html>

client/index.html

@@ -4,66 +4,168 @@
   <meta charset="utf-8"/>
   <title>GreenCoast — Client</title>
   <meta name="viewport" content="width=device-width,initial-scale=1"/>
+  <!-- Hard-pin API host so mobiles pick the right shard -->
+  <meta name="gc-api-base" content="https://api-gc.fullmooncyberworks.com">
   <link rel="stylesheet" href="./styles.css"/>
 </head>
 <body>
-  <div class="container">
+  <header class="topbar">
-    <h1>GreenCoast (Client)</h1>
+    <div class="brand">GreenCoast</div>
+    <nav class="tabs">
+      <a data-route href="#/">Feed</a>
+      <a data-route href="#/privacy">Privacy</a>
+      <a data-route href="#/gdpr">GDPR</a>
+      <a data-route href="#/terms">Terms</a>
+    </nav>
+    <div class="actions">
+      <button id="signIn" type="button">Sign in (device key)</button>
+      <button id="discordStart" type="button">Discord</button>
+      <button id="panic" type="button">Panic wipe</button>
+    </div>
+  </header>
 
-    <section class="card">
+  <div id="capWarn" class="warn is-hidden"></div>
-      <h2>Connect</h2>
+
-      <div class="row">
+  <div id="banner" class="banner is-hidden">
-        <label>Shard URL</label>
+    You are in <strong>anonymous (limited) mode</strong>. Only plaintext posts are available until you authorize this device.
-        <input id="shardUrl" placeholder="http://localhost:8080" />
+  </div>
-      </div>
+
-      <div class="row">
+  <div class="shell">
-        <label>Bearer (optional)</label>
+    <aside id="left" class="col">
-        <input id="bearer" placeholder="dev-local-token" />
+      <section class="card">
-      </div>
+        <h3>Profile</h3>
-      <div class="row">
+        <div class="profile">
-        <label>Passphrase (private posts)</label>
+          <img id="avatar" alt="avatar" width="56" height="56"/>
-        <input id="passphrase" type="password" placeholder="••••••••" />
+          <div class="profile-meta">
-      </div>
+            <div><code id="fp">(pseudonymous)</code></div>
-      <div class="row">
+            <div class="muted small">Avatar is derived locally.</div>
-        <label>3rd-party SSO</label>
-        <div>
-          <button id="discordStart">Sign in with Discord</button>
-          <div class="muted" style="margin-top:.4rem;">
-            We use external providers only if you choose to. We cannot vouch for their security.
           </div>
         </div>
-      </div>
+      </section>
-      <button id="saveConn">Save</button>
-      <div id="health" class="muted"></div>
-    </section>
 
-    <section class="card">
+      <section class="card">
-      <h2>Compose</h2>
+        <h3>Quick links</h3>
-      <div class="row">
+        <ul class="links">
-        <label>Visibility</label>
+          <li><a data-route href="#/">Feed</a></li>
-        <select id="visibility">
+          <li><a data-route href="#/privacy">Privacy Policy</a></li>
-          <option value="public">Public (plaintext)</option>
+          <li><a data-route href="#/gdpr">GDPR</a></li>
-          <option value="private">Private (E2EE via passphrase)</option>
+          <li><a data-route href="#/terms">Terms</a></li>
-        </select>
+        </ul>
-      </div>
+      </section>
-      <div class="row">
+    </aside>
-        <label>Title</label>
-        <input id="title" placeholder="Optional title"/>
-      </div>
-      <div class="row">
-        <label>Body</label>
-        <textarea id="body" rows="6" placeholder="Write your post..."></textarea>
-      </div>
-      <button id="publish">Publish</button>
-      <div id="publishStatus" class="muted"></div>
-    </section>
 
-    <section class="card">
+    <main id="feed" class="col">
-      <h2>Posts (live index)</h2>
+      <section class="card">
-      <div id="posts"></div>
+        <h2>Connection</h2>
-    </section>
+        <div class="row">
+          <label>Shard URL</label>
+          <input id="shardUrl" placeholder="https://api-gc.fullmooncyberworks.com"/>
+        </div>
+
+        <details id="adv" class="advanced">
+          <summary>Advanced (security)</summary>
+          <div class="row">
+            <label>Bearer (hidden)</label>
+            <input id="bearer" type="password" placeholder="gc2 token" autocomplete="off"/>
+          </div>
+          <div class="row">
+            <label>Passphrase (for Private-Encrypted)</label>
+            <input id="passphrase" type="password" placeholder="••••••••" autocomplete="off"/>
+          </div>
+          <p class="muted small">
+            Security fields are local to your browser. We do not store PII or logs.
+            Third-party SSO is optional and not endorsed for security.
+          </p>
+        </details>
+
+        <button id="saveConn" type="button">Save</button>
+        <div id="health" class="muted"></div>
+      </section>
+
+      <!-- Cross-post -->
+      <section class="card">
+        <h2>Share (x-post, privacy-safe)</h2>
+        <div class="row">
+          <label>Link</label>
+          <input id="shareUrl" placeholder="https://www.tiktok.com/@user/video/..." />
+        </div>
+        <div class="row">
+          <label>Note</label>
+          <input id="shareNote" placeholder="Optional caption…"/>
+        </div>
+        <div class="row">
+          <label>Visibility</label>
+          <select id="shareVis">
+            <option value="plaintext">Plaintext</option>
+            <option value="members">Public-Encrypted (members)</option>
+            <option value="private">Private-Encrypted (passphrase)</option>
+          </select>
+        </div>
+        <div class="row">
+          <button id="sharePreview" type="button">Preview</button>
+          <button id="sharePublish" type="button">Publish link</button>
+        </div>
+        <div id="shareCard" class="xcard muted small"></div>
+      </section>
+
+      <section class="card">
+        <h2>Compose</h2>
+        <div class="row">
+          <label>Visibility</label>
+          <select id="visibility">
+            <option value="plaintext">Plaintext (last resort)</option>
+            <option value="members">Public-Encrypted (members)</option>
+            <option value="private">Private-Encrypted (passphrase)</option>
+          </select>
+        </div>
+        <div class="row">
+          <label>Title</label>
+          <input id="title" placeholder="Optional title"/>
+        </div>
+        <div class="row">
+          <label>Body</label>
+          <textarea id="body" rows="6" placeholder="Write your post..."></textarea>
+        </div>
+        <button id="publish" type="button">Publish</button>
+        <div id="publishStatus" class="muted status"></div>
+      </section>
+
+      <section class="card">
+        <h2>Posts (live index)</h2>
+        <div id="posts"></div>
+      </section>
+    </main>
+
+    <main id="page" class="col is-hidden">
+      <section class="card">
+        <div id="pageContent">Loading…</div>
+      </section>
+    </main>
+
+    <aside id="right" class="col">
+      <section class="card">
+        <h3>About</h3>
+        <p class="muted small">Welcome to GreenCoast, a privacy-focused social media site. Zero-trust, E2EE optional, no analytics, no PII.</p>
+      </section>
+      <section class="card">
+        <h3>Legal</h3>
+        <ul class="links">
+          <li><a data-route href="#/privacy">Privacy</a></li>
+          <li><a data-route href="#/gdpr">GDPR</a></li>
+          <li><a data-route href="#/terms">Terms</a></li>
+        </ul>
+      </section>
+    </aside>
   </div>
 
+  <footer class="footer">
+    <a data-route href="#/privacy">Privacy</a> ·
+    <a data-route href="#/gdpr">GDPR</a> ·
+    <a data-route href="#/terms">Terms</a>
+  </footer>
+
+  <div id="flash" class="flash"></div>
+
   <script type="module" src="./app.js"></script>
 </body>
 </html>

client/privacy.html

@@ -0,0 +1,41 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <title>Privacy Policy — GreenCoast</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1"/>
+  <link rel="stylesheet" href="./styles.css"/>
+</head>
+<body class="container">
+  <h1>Privacy Policy</h1>
+  <p class="muted">Effective: 2025-08-22</p>
+
+  <h2>What we are</h2>
+  <p>GreenCoast is a zero-trust, end-to-end encrypted (E2EE) social platform. By default, we do not collect analytics, do not store personal data, and do not maintain server logs that identify users.</p>
+
+  <h2>Data we process</h2>
+  <ul>
+    <li><strong>Public posts:</strong> Stored as plaintext objects keyed by content hash. No account profile is required.</li>
+    <li><strong>Private posts:</strong> Encrypted <em>client-side</em> with a passphrase only you know. The server sees ciphertext only.</li>
+    <li><strong>Authorization:</strong> Device-key and/or third-party SSO (if you choose) issue a short-lived bearer. We do not persist profile data.</li>
+  </ul>
+
+  <h2>Third-party SSO</h2>
+  <p>If you use Discord/Google/etc., those providers may process your data under their own terms. We cannot vouch for their security.</p>
+
+  <h2>Cookies & local storage</h2>
+  <p>We use browser storage on your device to keep connection settings and, if you choose, session tokens. You can wipe them with “Panic wipe”.</p>
+
+  <h2>Security</h2>
+  <p>E2EE for private content, proof-of-possession on mutations, rate-limits, CSP/COOP/COEP, and optional hardware keys via WebAuthn (if enabled on your shard).</p>
+
+  <h2>Your rights</h2>
+  <p>Because we do not maintain user identities or server-side profiles, requests to access/correct/erase personal data typically do not apply. For encrypted content, we cannot decrypt it for you.</p>
+
+  <h2>Contact</h2>
+  <p>Email: <em>dsapelli@yahoo.com</em></p>
+
+  <p class="muted small">This page describes our reference shard. Self-hosted deployments may differ.</p>
+  <p><a href="./index.html">Back</a></p>
+</body>
+</html>

client/styles.css

@@ -1,18 +1,72 @@
-:root { --bg:#0b1117; --card:#0f1621; --fg:#e6edf3; --muted:#8b949e; --accent:#2ea043; }
+:root{
-* { box-sizing: border-box; }
+  --bg:#0f172a;--surface:#111827;--muted:#8b949e;--text:#e5e7eb;--accent:#22c55e;
-body { margin:0; font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Arial; background:var(--bg); color:var(--fg); }
+  --card:#0b1222;--border:#1f2937;--tab:#0b1222;--tab-active:#1f2937
-.container { max-width: 900px; margin: 2rem auto; padding: 0 1rem; }
+}
-h1 { font-size: 1.5rem; margin-bottom: 1rem; }
+*{box-sizing:border-box}
-.card { background: var(--card); border-radius: 14px; padding: 1rem; margin-bottom: 1rem; box-shadow: 0 8px 24px rgba(0,0,0,.3); }
+html,body{margin:0;padding:0;background:var(--bg);color:var(--text);
-h2 { margin-top: 0; font-size: 1.1rem; }
+  font-family:ui-sans-serif,system-ui,Segoe UI,Roboto,Ubuntu,"Helvetica Neue","Noto Sans",Arial}
-.row { display: grid; grid-template-columns: 160px 1fr; gap: .75rem; align-items: center; margin: .5rem 0; }
+a{color:#93c5fd;text-decoration:none}
-label { color: var(--muted); }
+a:hover{text-decoration:underline}
-input, select, textarea { width: 100%; padding: .6rem .7rem; border-radius: 10px; border: 1px solid #233; background: #0b1520; color: var(--fg); }
+
-button { background: var(--accent); color: #08130b; border: none; padding: .6rem .9rem; border-radius: 10px; cursor: pointer; font-weight: 700; }
+.topbar{display:flex;align-items:center;justify-content:space-between;padding:.6rem 1rem;
-button:hover { filter: brightness(1.05); }
+  border-bottom:1px solid var(--border);background:#0b1222;position:sticky;top:0;z-index:10}
-.muted { color: var(--muted); margin-top: .5rem; font-size: .9rem; }
+.brand{font-weight:700}
-.post { border: 1px solid #1d2734; border-radius: 12px; padding: .75rem; margin: .5rem 0; background: #0c1824; }
+.actions button{margin-left:.5rem}
-.post .meta { font-size: .85rem; color: var(--muted); margin-bottom: .4rem; }
+button{background:#134e4a;border:1px solid #0f766e;color:white;border-radius:.6rem;padding:.45rem .7rem;cursor:pointer}
-.post .actions { margin-top: .5rem; display:flex; gap:.5rem; }
+button:hover{filter:brightness(1.05)}
-code { background:#0a1320; padding:.15rem .35rem; border-radius:6px; }
+input[type="password"]{letter-spacing:.2em}
-.badge { font-size:.75rem; padding:.1rem .4rem; border-radius: 999px; background:#132235; color:#9fb7d0; margin-left:.5rem; }
+
+.tabs{display:flex;gap:.25rem;margin:0 .75rem}
+.tabs a{padding:.35rem .6rem;border:1px solid var(--border);border-radius:.5rem;background:var(--tab)}
+.tabs a.active{background:var(--tab-active);border-color:#334155}
+
+.banner{background:#1f2937;color:#e5e7eb;border-bottom:1px solid var(--border);padding:.6rem 1rem}
+
+.shell{max-width:1100px;margin:1rem auto;display:grid;grid-template-columns:280px 1fr 300px;gap:1rem;padding:0 1rem}
+.col{min-width:0}
+.card{background:var(--card);border:1px solid var(--border);border-radius:.75rem;padding:1rem;margin-bottom:1rem}
+.row{display:flex;gap:.75rem;align-items:center;margin:.5rem 0}
+.row label{min-width:140px;color:#cbd5e1}
+.row input,.row select,textarea{flex:1;background:#0f172a;border:1px solid var(--border);border-radius:.5rem;padding:.55rem .65rem;color:var(--text)}
+.muted{color:var(--muted)} .small{font-size:.9rem}
+.profile{display:flex;align-items:center;gap:1rem}
+#avatar{border-radius:50%;border:1px solid var(--border);background:#0f172a;image-rendering:pixelated}
+
+.post{border:1px dashed var(--border);border-radius:.5rem;padding:.6rem .7rem;margin-bottom:.6rem}
+.post .meta{color:var(--muted);font-size:.9rem;margin-bottom:.25rem}
+.badge{background:var(--surface);border:1px solid var(--border);border-radius:999px;padding:.05rem .5rem;font-size:.75rem;margin-left:.5rem}
+
+.advanced summary{cursor:pointer;color:#cbd5e1;margin:.25rem 0}
+.links{list-style:none;padding:0;margin:0}
+.links li{margin:.25rem 0}
+
+.footer{max-width:1100px;margin:1rem auto 2rem auto;padding:0 1rem;color:#94a3b8}
+
+.flash{position:fixed;right:12px;bottom:12px;background:#0b1222;border:1px solid #1f2937;color:#e5e7eb;
+  padding:.55rem .7rem;border-radius:.5rem;box-shadow:0 6px 18px rgba(0,0,0,.35);display:none;z-index:9999}
+.flash.visible{display:block}
+
+.warn{background:#3b1d1d;border:1px solid #7f1d1d;color:#ffd7d7;padding:.6rem .8rem;border-radius:.6rem;margin:0 1rem 1rem}
+.banner{margin:0 1rem 1rem;padding:.6rem .8rem;border-radius:.6rem;background:#10212b;border:1px solid #1d3340;color:#dbeafe}
+
+.is-hidden{display:none !important}
+.mt-4{margin-top:.4rem}
+
+/* content presentation that was previously set via JS */
+.pre-content{white-space:pre-wrap;margin-top:.5rem}
+.status.error{color:#ff6b6b}
+.status.ok{color:#8b949e}
+
+/* x-post chips */
+.xcard{border:1px solid #263444;border-radius:.5rem;padding:.6rem}
+.xrow{display:flex;gap:.5rem;align-items:center}
+.xpill{font-size:.85rem;border:1px solid #30445a;border-radius:999px;padding:.1rem .5rem}
+.xtitle{font-weight:600}
+.xmeta{opacity:.85;margin:.25rem 0}
+.xbtn{margin-top:.25rem}
+code{background:#0f172a;border:1px solid var(--border);border-radius:.35rem;padding:.05rem .35rem}
+@media (max-width: 980px){
+  .shell{grid-template-columns:1fr;gap:.75rem}
+  #left,#right{order:2}
+  #feed,#page{order:1}
+}

client/terms.html

@@ -0,0 +1,33 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8"/>
+  <title>Terms of Service — GreenCoast</title>
+  <meta name="viewport" content="width=device-width,initial-scale=1"/>
+  <link rel="stylesheet" href="./styles.css"/>
+</head>
+<body class="container">
+  <h1>Terms of Service</h1>
+  <p class="muted">Effective: 2025-08-22</p>
+
+  <h2>Service</h2>
+  <p>GreenCoast is provided “as-is”, with no warranties. You may self-host under the Unlicense. This reference shard has no paid plans.</p>
+
+  <h2>User content</h2>
+  <p>You are responsible for content you publish. Do not post illegal content or abuse others. We reserve the right to remove content that violates applicable law.</p>
+
+  <h2>Accounts & authorization</h2>
+  <p>Device-key and optional SSO are used to prove control of a device. We do not maintain user profiles.</p>
+
+  <h2>Third-party services</h2>
+  <p>If you connect SSO providers, your use of those services is governed by their terms and privacy policies.</p>
+
+  <h2>Limitation of liability</h2>
+  <p>To the fullest extent permitted by law, the operator is not liable for indirect or consequential damages.</p>
+
+  <h2>Changes</h2>
+  <p>We may update these Terms by posting a new version on this page.</p>
+
+  <p><a href="./index.html">Back</a></p>
+</body>
+</html>

cmd/shard/main.go

@@ -1,89 +1,241 @@
+// cmd/shard/main.go
 package main
 
 import (
-	"flag"
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
 	"log"
+	"os"
 	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
 
 	"greencoast/internal/api"
-	"greencoast/internal/config"
-	"greencoast/internal/federation"
 	"greencoast/internal/index"
-	"greencoast/internal/storage"
+
+	"gopkg.in/yaml.v3"
 )
 
-func main() {
+type cfgPrivacy struct {
-	cfgPath := flag.String("config", "shard.yaml", "path to config")
+	AllowAnonPlaintext bool `yaml:"allow_anon_plaintext"`
-	flag.Parse()
+}
-
+type shardConfig struct {
-	cfg, err := config.Load(*cfgPath)
+	Privacy cfgPrivacy `yaml:"privacy"`
-	if err != nil {
+}
-		log.Fatalf("config error: %v", err)
+
-	}
+func boolEnv(keys ...string) bool {
-
+	for _, k := range keys {
-	store, err := storage.NewFSStore(cfg.Storage.Path, cfg.Storage.MaxObjectKB)
+		v := strings.ToLower(strings.TrimSpace(os.Getenv(k)))
-	if err != nil {
+		if v == "1" || v == "true" || v == "yes" || v == "on" {
-		log.Fatalf("storage error: %v", err)
+			return true
-	}
+		}
-
+	}
-	dataRoot := filepath.Dir(cfg.Storage.Path)
+	return false
-	idx := index.New(dataRoot)
+}
-
+
-	srv := api.New(
+func loadYAMLAllow(path string) bool {
-		store, idx,
+	f, err := os.Open(path)
-		cfg.Privacy.RetainTimestamps == "coarse",
+	if err != nil {
-		cfg.Security.ZeroTrust,
+		return false
-		api.AuthProviders{
+	}
-			SigningSecretHex: cfg.Auth.SigningSecret,
+	defer f.Close()
-			Discord: api.DiscordProvider{
+	var sc shardConfig
-				Enabled:      cfg.Auth.SSO.Discord.Enabled,
+	if err := yaml.NewDecoder(f).Decode(&sc); err != nil {
-				ClientID:     cfg.Auth.SSO.Discord.ClientID,
+		return false
-				ClientSecret: cfg.Auth.SSO.Discord.ClientSecret,
+	}
-				RedirectURI:  cfg.Auth.SSO.Discord.RedirectURI,
+	return sc.Privacy.AllowAnonPlaintext
-			},
+}
-			GoogleEnabled:   cfg.Auth.SSO.Google.Enabled,
+
-			FacebookEnabled: cfg.Auth.SSO.Facebook.Enabled,
+/* -------------------------
-			WebAuthnEnabled: cfg.Auth.TwoFactor.WebAuthnEnabled,
+   Minimal FS blob store (implements api.BlobStore)
-			TOTPEnabled:     cfg.Auth.TwoFactor.TOTPEnabled,
+   Layout:
-		},
+     /var/lib/greencoast/objects/<hash>       content
-	)
+     /var/lib/greencoast/objects/<hash>.priv  empty sidecar => private
-
+--------------------------*/
-	// Optional: also mount static under API mux (subpath) if you later want that.
+
-	// srv.MountStatic(cfg.UI.Path, "/app")
+type fsStore struct {
-
+	root string
-	// Start federation mTLS (if enabled)
+}
-	if cfg.Federation.MTLSEnable {
+
-		tlsCfg, err := federation.ServerTLSConfig(
+func newFSStore(root string) *fsStore { return &fsStore{root: root} }
-			cfg.Federation.CertFile,
+
-			cfg.Federation.KeyFile,
+func (s *fsStore) ensureRoot() error {
-			cfg.Federation.ClientCAFile,
+	// create both parent and leaf to be safe on fresh volumes
-		)
+	if err := os.MkdirAll(filepath.Dir(s.root), 0o755); err != nil {
-		if err != nil {
+		return err
-			log.Fatalf("federation tls config error: %v", err)
+	}
-		}
+	return os.MkdirAll(s.root, 0o755)
-		go func() {
+}
-			if err := srv.ListenMTLS(cfg.Federation.Listen, tlsCfg); err != nil {
+func (s *fsStore) pathFor(hash string) string     { return filepath.Join(s.root, hash) }
-				log.Fatalf("federation mTLS listener error: %v", err)
+func (s *fsStore) privPathFor(hash string) string { return filepath.Join(s.root, hash+".priv") }
-			}
+
-		}()
+func (s *fsStore) Get(hash string) (io.ReadCloser, int64, error) {
-	}
+	if err := s.ensureRoot(); err != nil {
-
+		return nil, 0, err
-	// Start FRONTEND listener (separate port) if enabled
+	}
-	if cfg.UI.Enable && cfg.UI.FrontendHTTP != "" {
+	f, err := os.Open(s.pathFor(hash))
-		go func() {
+	if err != nil {
-			if err := srv.ListenFrontendHTTP(cfg.UI.FrontendHTTP, cfg.UI.Path, cfg.UI.BaseURL); err != nil {
+		return nil, 0, err
-				log.Fatalf("frontend listener error: %v", err)
+	}
-			}
+	st, err := f.Stat()
-		}()
+	if err != nil {
-	}
+		_ = f.Close()
-
+		return nil, 0, err
-	// Choose ONE foreground listener for API: HTTPS if enabled, else HTTP.
+	}
-	if cfg.TLS.Enable && cfg.Listen.HTTPS != "" {
+	return f, st.Size(), nil
-		log.Fatal(srv.ListenHTTPS(cfg.Listen.HTTPS, cfg.TLS.CertFile, cfg.TLS.KeyFile))
+}
-		return
+
-	}
+func (s *fsStore) Put(r io.Reader, private bool) (string, int64, time.Time, error) {
-	if cfg.Listen.HTTP == "" {
+	if err := s.ensureRoot(); err != nil {
-		log.Fatal("no API listeners configured (set listen.http or listen.https)")
+		return "", 0, time.Time{}, err
-	}
+	}
-	log.Fatal(srv.ListenHTTP(cfg.Listen.HTTP))
+
+	tmp, err := os.CreateTemp(s.root, "put-*")
+	if err != nil {
+		return "", 0, time.Time{}, err
+	}
+	tmpName := tmp.Name()
+	defer func() {
+		// best-effort cleanup of temp path (original name)
+		_ = os.Remove(tmpName)
+	}()
+
+	h := sha256.New()
+	w := io.MultiWriter(tmp, h)
+	n, err := io.Copy(w, r)
+	if err != nil {
+		_ = tmp.Close()
+		return "", 0, time.Time{}, err
+	}
+
+	// IMPORTANT on Windows bind mounts: flush & close before rename
+	if err := tmp.Sync(); err != nil {
+		_ = tmp.Close()
+		return "", 0, time.Time{}, err
+	}
+	if err := tmp.Close(); err != nil {
+		return "", 0, time.Time{}, err
+	}
+
+	hash := hex.EncodeToString(h.Sum(nil))
+	final := s.pathFor(hash)
+
+	// If a previous file with this hash exists, remove it first (idempotent writes)
+	_ = os.Remove(final)
+
+	if err := os.Rename(tmpName, final); err != nil {
+		return "", 0, time.Time{}, err
+	}
+
+	// Optional: fsync directory to harden the rename on some filesystems
+	if df, err := os.Open(s.root); err == nil {
+		_ = syscall.Fsync(int(df.Fd()))
+		_ = df.Close()
+	}
+
+	st, err := os.Stat(final)
+	if err != nil {
+		return "", 0, time.Time{}, err
+	}
+
+	// create sidecar only after main content is durable
+	if private {
+		if err := os.WriteFile(s.privPathFor(hash), nil, 0o600); err != nil {
+			_ = os.Remove(final)
+			return "", 0, time.Time{}, err
+		}
+	}
+
+	return hash, n, st.ModTime().UTC(), nil
+}
+
+func (s *fsStore) Delete(hash string) error {
+	if err := s.ensureRoot(); err != nil {
+		return err
+	}
+	_ = os.Remove(s.privPathFor(hash))
+	return os.Remove(s.pathFor(hash))
+}
+
+func (s *fsStore) Walk(fn func(hash string, bytes int64, private bool, storedAt time.Time) error) (int, error) {
+	if err := s.ensureRoot(); err != nil {
+		return 0, err
+	}
+	ents, err := os.ReadDir(s.root)
+	if err != nil {
+		return 0, err
+	}
+	count := 0
+	for _, e := range ents {
+		if e.IsDir() {
+			continue
+		}
+		name := e.Name()
+		// skip sidecars and non-64-hex filenames
+		if strings.HasSuffix(name, ".priv") || len(name) != 64 || !isHex(name) {
+			continue
+		}
+		full := s.pathFor(name)
+		st, err := os.Stat(full)
+		if err != nil {
+			continue
+		}
+		private := false
+		if _, err := os.Stat(s.privPathFor(name)); err == nil {
+			private = true
+		}
+		if err := fn(name, st.Size(), private, st.ModTime().UTC()); err != nil {
+			return count, err
+		}
+		count++
+	}
+	return count, nil
+}
+
+func isHex(s string) bool {
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if !((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
+			return false
+		}
+	}
+	return true
+}
+
+/* -------------------------
+   main
+--------------------------*/
+
+func main() {
+	// Store & index
+	store := newFSStore("/var/lib/greencoast/objects")
+	idx := index.New()
+
+	// Flags: env wins, else YAML (/app/shard.yaml), else false
+	allowAnon := boolEnv("GC_ALLOW_ANON_PLAINTEXT")
+	if !allowAnon {
+		if st, err := os.Stat("/app/shard.yaml"); err == nil && !st.IsDir() {
+			allowAnon = loadYAMLAllow("/app/shard.yaml")
+		}
+	}
+	devMode := boolEnv("GC_DEV_ALLOW_UNAUTH")
+
+	log.Printf("boot: privacy.allow_anon_plaintext=%v  dev=%v  at=%s", allowAnon, devMode, time.Now().UTC().Format(time.RFC3339))
+
+	var providers api.AuthProviders
+	srv := api.New(store, idx, true, devMode, providers, allowAnon)
+
+	// Frontend (static)
+	go func() {
+		if err := srv.ListenFrontend("0.0.0.0:9082"); err != nil {
+			log.Printf("frontend server exited: %v", err)
+		}
+	}()
+
+	// API
+	if err := srv.ListenHTTP("0.0.0.0:9080"); err != nil {
+		log.Fatal(err)
+	}
 }

configs/shard.test.yaml

@@ -0,0 +1,62 @@
+shard_id: "gc-test-001"
+
+listen:
+  http: "0.0.0.0:9080"
+  https: ""
+  ws:   "0.0.0.0:9081"
+
+tls:
+  enable: false
+  cert_file: "/etc/greencoast/tls/cert.pem"
+  key_file:  "/etc/greencoast/tls/key.pem"
+
+federation:
+  mtls_enable: false
+  listen: "0.0.0.0:9443"
+  cert_file: "/etc/greencoast/fed/cert.pem"
+  key_file:  "/etc/greencoast/fed/key.pem"
+  client_ca_file: "/etc/greencoast/fed/clients_ca.pem"
+
+ui:
+  enable: true
+  path: "./client"
+  base_url: "/"
+  frontend_http: "0.0.0.0:9082"
+
+storage:
+  backend: "fs"
+  path: "/var/lib/greencoast/objects"
+  max_object_kb: 128
+
+security:
+  zero_trust: true
+  require_mtls_for_federation: true
+  accept_client_signed_tokens: true
+  log_level: "warn"
+
+privacy:
+  retain_ip: "no"
+  retain_user_agent: "no"
+  retain_timestamps: "coarse"
+  allow_anon_plaintext: true
+
+auth:
+  # Choose either YAML OR env for the signing secret — not both.
+  # If you keep it here, make sure it's EXACTLY the same as the env value.
+  signing_secret: GC_SIGNING_SECRET_HEX
+  sso:
+    discord:
+      enabled: true
+      client_id: GC_DISCORD_CLIENT_ID
+      client_secret: GC_DISCORD_CLIENT_SECRET
+      redirect_uri: GC_DISCORD_REDIRECT_URI
+    google:   { enabled: false, client_id: "", client_secret: "", redirect_uri: "" }
+    facebook: { enabled: false, client_id: "", client_secret: "", redirect_uri: "" }
+  two_factor:
+    webauthn_enabled: false
+    totp_enabled: false
+
+limits:
+  rate:
+    burst: 20
+    per_minute: 60

docker-compose.test.yml

@@ -0,0 +1,22 @@
+services:
+  shard-test:
+    build: .
+    env_file:
+      - .env
+    container_name: greencoast-shard-test
+    restart: unless-stopped
+    user: "0:0"
+    ports:
+      - "9080:9080"
+      - "9082:9082"
+    volumes:
+      - ./testdata:/var/lib/greencoast
+      - ./configs/shard.test.yaml:/app/shard.yaml:ro
+      - ./client:/app/client:ro
+
+  cloudflared:
+    image: cloudflare/cloudflared:latest
+    command: tunnel --no-autoupdate run --token ${CF_TUNNEL_TOKEN}
+    restart: unless-stopped
+    depends_on:
+      - shard-test

docker-compose.yml

@@ -11,6 +11,7 @@ services:
       - "8081:8081"
     environment:
       - GC_DEV_ALLOW_UNAUTH=false
+      - GC_SIGNING_SECRET_HEX=92650f92d67d55368c852713a5007b90d933bff507bc77c980de7bf5442844ca
     volumes:
       - gc_data:/var/lib/greencoast
       - ./configs/shard.sample.yaml:/app/shard.yaml:ro

internal/api/http.go

@@ -1,560 +1,395 @@
+// internal/api/http.go
 package api
 
 import (
-	"crypto/hmac"
+	"bufio"
-	"crypto/rand"
+	"bytes"
-	"crypto/sha256"
-	"crypto/tls"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"log"
-	"net"
 	"net/http"
-	"net/url"
 	"os"
-	"sort"
+	"path"
 	"strconv"
 	"strings"
 	"sync"
 	"time"
 
 	"greencoast/internal/index"
-	"greencoast/internal/storage"
 )
 
-// ----------- Auth Providers & config (SSO / 2FA stubs) ------------
+// ---- Contracts ----
 
-type DiscordProvider struct {
+type BlobStore interface {
-	Enabled      bool
+	Get(hash string) (io.ReadCloser, int64, error)
-	ClientID     string
+	Put(r io.Reader, private bool) (hash string, n int64, storedAt time.Time, err error)
-	ClientSecret string
+	Delete(hash string) error
-	RedirectURI  string
+	Walk(fn func(hash string, bytes int64, private bool, storedAt time.Time) error) (int, error)
 }
 
-type AuthProviders struct {
+type AuthProviders struct{}
-	SigningSecretHex string
-	Discord          DiscordProvider
-	GoogleEnabled    bool // placeholder
-	FacebookEnabled  bool // placeholder
-	WebAuthnEnabled  bool // placeholder
-	TOTPEnabled      bool // placeholder
-}
 
-// ----------- SSE hub (live index) ------------
+// ---- Server ----
-
-type sseEvent struct {
-	Event string      `json:"event"` // "put" | "delete"
-	Data  interface{} `json:"data"`
-}
-
-type hub struct {
-	mu   sync.Mutex
-	subs map[chan []byte]struct{}
-}
-
-func newHub() *hub { return &hub{subs: make(map[chan []byte]struct{})} }
-
-func (h *hub) subscribe() (ch chan []byte, cancel func()) {
-	ch = make(chan []byte, 16)
-	h.mu.Lock()
-	h.subs[ch] = struct{}{}
-	h.mu.Unlock()
-	cancel = func() {
-		h.mu.Lock()
-		if _, ok := h.subs[ch]; ok {
-			delete(h.subs, ch)
-			close(ch)
-		}
-		h.mu.Unlock()
-	}
-	return ch, cancel
-}
-func (h *hub) broadcast(ev sseEvent) {
-	b, _ := json.Marshal(ev)
-	line := append([]byte("data: "), b...)
-	line = append(line, '\n', '\n')
-	h.mu.Lock()
-	for ch := range h.subs {
-		select {
-		case ch <- line:
-		default:
-		}
-	}
-	h.mu.Unlock()
-}
-
-// ----------- Server ------------
 
 type Server struct {
-	mux       *http.ServeMux
+	Mux *http.ServeMux // exported for other files
-	store     *storage.FSStore
+	mux *http.ServeMux // alias
-	idx       *index.Index
-	coarseTS  bool
-	zeroTrust bool
 
-	signingSecret []byte
+	store BlobStore
-	discord       DiscordProvider
+	idx   *index.Index
+	uiOn  bool
 
-	devAllow bool
+	devAllowUnauth     bool
-	devToken string
+	allowAnonPlaintext bool
 
-	live *hub
+	StaticDir string
+
+	sseMu   sync.Mutex
+	sseSubs map[chan []byte]struct{}
 }
 
-func New(store *storage.FSStore, idx *index.Index, coarseTimestamps bool, zeroTrust bool, auth AuthProviders) *Server {
+// New(store, idx, enableUI, devMode, providers, allowAnonPlaintext)
-	devAllow := strings.ToLower(os.Getenv("GC_DEV_ALLOW_UNAUTH")) == "true"
+func New(store BlobStore, idx *index.Index, enableUI bool, devMode bool, _ AuthProviders, allowAnonPlaintext bool) *Server {
-	devToken := os.Getenv("GC_DEV_BEARER")
+	m := http.NewServeMux()
-	if devToken == "" {
-		devToken = "dev-local-token"
-	}
-
-	sec := make([]byte, 0)
-	if auth.SigningSecretHex != "" {
-		if b, err := hex.DecodeString(auth.SigningSecretHex); err == nil {
-			sec = b
-		}
-	}
-
 	s := &Server{
-		mux:           http.NewServeMux(),
+		Mux:                m,
-		store:         store,
+		mux:                m,
-		idx:           idx,
+		store:              store,
-		coarseTS:      coarseTimestamps,
+		idx:                idx,
-		zeroTrust:     zeroTrust,
+		uiOn:               enableUI,
-		signingSecret: sec,
+		devAllowUnauth:     devMode,
-		discord:       auth.Discord,
+		allowAnonPlaintext: allowAnonPlaintext,
-		devAllow:      devAllow,
+		StaticDir:          "./client",
-		devToken:      devToken,
+		sseSubs:            make(map[chan []byte]struct{}),
-		live:          newHub(),
 	}
-	s.routes()
+
+	// Health + caps
+	s.Mux.HandleFunc("/healthz", s.healthz)
+	s.Mux.HandleFunc("/v1/caps", s.handleCaps)
+
+	// Object I/O
+	s.Mux.Handle("/v1/object", s.requireAuth(http.HandlerFunc(s.handlePutObject)))     // PUT
+	s.Mux.Handle("/v1/object/", s.requireAuth(http.HandlerFunc(s.handleObjectByHash))) // GET/DELETE
+
+	// Index (public read)
+	s.Mux.HandleFunc("/v1/index", s.handleIndex)
+	s.Mux.HandleFunc("/v1/index/stream", s.handleIndexStream)
+
 	return s
 }
 
-// ---------- helpers (privacy headers, CORS, util) ----------
+func (s *Server) ListenHTTP(addr string) error {
-
+	handler := corsSecurity(s.Mux)
-func (s *Server) secureHeaders(w http.ResponseWriter) {
+	server := &http.Server{Addr: addr, Handler: handler}
-	// Anti-fingerprinting posture
+	return server.ListenAndServe()
-	w.Header().Set("Referrer-Policy", "no-referrer")
-	w.Header().Set("Permissions-Policy", "camera=(), microphone=(), geolocation=(), interest-cohort=(), browsing-topics=()")
-	w.Header().Set("X-Content-Type-Options", "nosniff")
-	w.Header().Set("X-Frame-Options", "DENY")
-	w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
-	w.Header().Set("Cross-Origin-Resource-Policy", "same-site")
-	w.Header().Set("Access-Control-Allow-Origin", "*")
-	w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type, X-GC-Private, X-GC-3P-Assent")
-	w.Header().Set("Access-Control-Allow-Methods", "GET, PUT, DELETE, OPTIONS")
-	w.Header().Set("Cache-Control", "no-store")
-	w.Header().Set("Strict-Transport-Security", "max-age=15552000; includeSubDomains; preload")
 }
 
-func (s *Server) with(w http.ResponseWriter, r *http.Request, handler func(http.ResponseWriter, *http.Request)) {
+// ---- Global CORS/security ----
-	s.secureHeaders(w)
-	if r.Method == http.MethodOptions {
-		w.WriteHeader(http.StatusNoContent)
-		return
-	}
-	handler(w, r)
-}
 
-func urlq(v string) string { return url.QueryEscape(v) }
+func corsSecurity(next http.Handler) http.Handler {
-
+	allowedHeaders := "Authorization, Content-Type, X-GC-Private, X-GC-3P-Assent, X-GC-TZ, X-GC-Key, X-GC-TS, X-GC-Proof"
-// Generic helper must be package-level (methods cannot have type parameters).
+	allowedMethods := "GET, PUT, POST, DELETE, OPTIONS"
-func ternary[T any](cond bool, a, b T) T {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-	if cond {
+		w.Header().Set("Access-Control-Allow-Origin", "*")
-		return a
+		w.Header().Set("Access-Control-Allow-Methods", allowedMethods)
-	}
+		w.Header().Set("Access-Control-Allow-Headers", allowedHeaders)
-	return b
+		w.Header().Set("X-Content-Type-Options", "nosniff")
-}
+		w.Header().Set("X-Frame-Options", "DENY")
-
+		w.Header().Set("Referrer-Policy", "no-referrer")
-func randHex(n int) string {
+		w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
-	b := make([]byte, n)
+		w.Header().Set("Cross-Origin-Resource-Policy", "same-site")
-	if _, err := rand.Read(b); err != nil {
+		w.Header().Set("Permissions-Policy", "camera=(), microphone=(), geolocation=(), interest-cohort=(), browsing-topics=()")
-		ts := time.Now().UnixNano()
+		if r.Method == http.MethodOptions {
-		for i := 0; i < n; i++ {
+			w.WriteHeader(http.StatusNoContent)
-			b[i] = byte(ts >> (8 * (i % 8)))
-		}
-	}
-	return hex.EncodeToString(b)
-}
-
-// ---------- auth middleware ----------
-
-func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request) {
-		s.secureHeaders(w)
-		if !s.zeroTrust {
-			next.ServeHTTP(w, r)
-			return
-		}
-		authz := r.Header.Get("Authorization")
-
-		// Dev bypass if explicitly enabled
-		if s.devAllow {
-			if authz == "" || authz == "Bearer "+s.devToken {
-				next.ServeHTTP(w, r)
-				return
-			}
-		}
-		if !strings.HasPrefix(authz, "Bearer ") {
-			http.Error(w, "unauthorized", http.StatusUnauthorized)
-			return
-		}
-		if len(s.signingSecret) == 0 {
-			next.ServeHTTP(w, r)
-			return
-		}
-		token := strings.TrimPrefix(authz, "Bearer ")
-		if ok := s.verifyShardToken(token); !ok {
-			http.Error(w, "unauthorized", http.StatusUnauthorized)
 			return
 		}
 		next.ServeHTTP(w, r)
-	}
-}
-
-// ---------- shard token (HMAC, short-lived) ----------
-
-// Format: gc|prov|sub|expEpoch|hex(hmacSHA256(secret, prov+'|'+sub+'|'+exp))
-func (s *Server) signShardToken(provider, subject string, exp time.Time) (string, error) {
-	if len(s.signingSecret) == 0 {
-		return "", errors.New("signing disabled (missing auth.signing_secret)")
-	}
-	msg := provider + "|" + subject + "|" + fmt.Sprint(exp.Unix())
-	mac := hmac.New(sha256.New, s.signingSecret)
-	_, _ = mac.Write([]byte(msg))
-	sig := hex.EncodeToString(mac.Sum(nil))
-	return "gc|" + msg + "|" + sig, nil
-}
-
-func (s *Server) verifyShardToken(tok string) bool {
-	parts := strings.Split(tok, "|")
-	if len(parts) != 5 || parts[0] != "gc" {
-		return false
-	}
-	prov, sub, expStr, sig := parts[1], parts[2], parts[3], parts[4]
-	_ = prov
-	_ = sub
-	msg := prov + "|" + sub + "|" + expStr
-	mac := hmac.New(sha256.New, s.signingSecret)
-	_, _ = mac.Write([]byte(msg))
-	want := hex.EncodeToString(mac.Sum(nil))
-	if !hmac.Equal([]byte(want), []byte(sig)) {
-		return false
-	}
-	expUnix, err := strconv.ParseInt(expStr, 10, 64)
-	if err != nil {
-		return false
-	}
-	return time.Now().UTC().Unix() < expUnix
-}
-
-// ---------- routes ----------
-
-func (s *Server) routes() {
-	s.mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
-		s.with(w, r, func(w http.ResponseWriter, _ *http.Request) {
-			w.WriteHeader(http.StatusOK)
-			_, _ = w.Write([]byte("ok"))
-		})
 	})
+}
 
-	// PUT object (opaque). Client may flag privacy in index via X-GC-Private: 1.
+// ---- Auth (with anon-plaintext bypass) ----
-	s.mux.HandleFunc("/v1/object", s.auth(func(w http.ResponseWriter, r *http.Request) {
-		s.with(w, r, func(w http.ResponseWriter, r *http.Request) {
-			if r.Method != http.MethodPut {
-				http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-				return
-			}
-			isPrivate := strings.TrimSpace(r.Header.Get("X-GC-Private")) == "1"
-			hash, n, err := s.store.Put(r.Body)
-			if err != nil {
-				http.Error(w, err.Error(), http.StatusBadRequest)
-				return
-			}
-			ts := s.nowCoarse()
-			_ = s.idx.AppendPut(index.Entry{
-				Hash: hash, Bytes: n, StoredAt: s.parseRFC3339(ts), Private: isPrivate,
-			})
-			s.live.broadcast(sseEvent{Event: "put", Data: map[string]any{
-				"hash": hash, "bytes": n, "stored_at": ts, "private": isPrivate,
-			}})
-			w.Header().Set("Content-Type", "application/json")
-			fmt.Fprintf(w, `{"ok":true,"hash":"%s","bytes":%d,"stored_at":"%s"}`, hash, n, ts)
-		})
-	}))
 
-	// GET/DELETE object by hash
+func (s *Server) isPlaintextPut(r *http.Request) bool {
-	s.mux.HandleFunc("/v1/object/", s.auth(func(w http.ResponseWriter, r *http.Request) {
+	if !s.allowAnonPlaintext {
-		s.with(w, r, func(w http.ResponseWriter, r *http.Request) {
+		return false
-			switch r.Method {
+	}
-			case http.MethodGet:
+	if r.Method != http.MethodPut {
-				hash := strings.TrimPrefix(r.URL.Path, "/v1/object/")
+		return false
-				p, err := s.store.Get(hash)
+	}
-				if err != nil {
+	if !strings.HasPrefix(r.URL.Path, "/v1/object") {
-					http.NotFound(w, r)
+		return false
-					return
+	}
-				}
+	if r.Header.Get("X-GC-Private") == "1" {
-				f, err := os.Open(p)
+		return false
-				if err != nil {
+	}
-					http.Error(w, "open error", http.StatusInternalServerError)
+	return true
-					return
+}
-				}
-				defer f.Close()
-				w.Header().Set("Content-Type", "application/octet-stream")
-				_, _ = io.Copy(w, f)
-			case http.MethodDelete:
-				hash := strings.TrimPrefix(r.URL.Path, "/v1/object/")
-				if err := s.store.Delete(hash); err != nil {
-					http.NotFound(w, r)
-					return
-				}
-				_ = s.idx.AppendDelete(hash)
-				s.live.broadcast(sseEvent{Event: "delete", Data: map[string]any{"hash": hash}})
-				w.Header().Set("Content-Type", "application/json")
-				_, _ = w.Write([]byte(`{"ok":true,"deleted":true}`))
-			default:
-				http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-			}
-		})
-	}))
 
-	// Index snapshot
+func (s *Server) requireAuth(next http.Handler) http.Handler {
-	s.mux.HandleFunc("/v1/index", s.auth(func(w http.ResponseWriter, r *http.Request) {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		s.with(w, r, func(w http.ResponseWriter, r *http.Request) {
+		if s.isPlaintextPut(r) || s.devAllowUnauth {
-			if r.Method != http.MethodGet {
+			next.ServeHTTP(w, r)
-				http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-				return
-			}
-			entries, err := s.idx.Snapshot()
-			if err != nil {
-				http.Error(w, err.Error(), 500)
-				return
-			}
-			sort.Slice(entries, func(i, j int) bool { return entries[i].StoredAt.After(entries[j].StoredAt) })
-			w.Header().Set("Content-Type", "application/json")
-			_ = json.NewEncoder(w).Encode(entries)
-		})
-	}))
-
-	// Index live (SSE)
-	s.mux.HandleFunc("/v1/index/stream", s.auth(func(w http.ResponseWriter, r *http.Request) {
-		s.secureHeaders(w)
-		flusher, ok := w.(http.Flusher)
-		if !ok {
-			http.Error(w, "stream unsupported", http.StatusInternalServerError)
 			return
 		}
-		w.Header().Set("Content-Type", "text/event-stream")
+		bearer := strings.TrimSpace(strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer"))
-		w.Header().Set("Cache-Control", "no-store")
+		hasPoP := r.Header.Get("X-GC-Key") != "" && r.Header.Get("X-GC-TS") != "" && r.Header.Get("X-GC-Proof") != ""
-		w.Header().Set("Connection", "keep-alive")
+		if bearer != "" || hasPoP {
-
+			next.ServeHTTP(w, r)
-		ch, cancel := s.live.subscribe()
+			return
-		defer cancel()
-
-		_, _ = w.Write([]byte(": ok\n\n"))
-		flusher.Flush()
-		ticker := time.NewTicker(25 * time.Second)
-		defer ticker.Stop()
-		notify := r.Context().Done()
-		for {
-			select {
-			case <-notify:
-				return
-			case <-ticker.C:
-				_, _ = w.Write([]byte(": ping\n\n"))
-				flusher.Flush()
-			case msg, ok := <-ch:
-				if !ok {
-					return
-				}
-				_, _ = w.Write(msg)
-				flusher.Flush()
-			}
 		}
-	}))
+		http.Error(w, "unauthorized", http.StatusUnauthorized)
-
-	// GDPR policy + Third-party disclaimer
-	s.mux.HandleFunc("/v1/gdpr/policy", func(w http.ResponseWriter, r *http.Request) {
-		s.with(w, r, func(w http.ResponseWriter, _ *http.Request) {
-			w.Header().Set("Content-Type", "application/json")
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"collect_ip":        false,
-				"collect_useragent": false,
-				"timestamp_policy":  ternary(s.coarseTS, "coarse-hour", "exact"),
-				"stores_pii":        false,
-				"erasure":           "DELETE /v1/object/{hash}",
-				"portability":       "GET /v1/object/{hash}",
-				"third_party_auth":  "Using external SSO providers is optional. We cannot vouch for their security; proceed only if you trust the provider.",
-			})
-		})
-	})
-
-	// ---------- Discord SSO (first provider) ----------
-
-	// Start: returns authorization URL. Requires explicit assent.
-	s.mux.HandleFunc("/v1/auth/discord/start", func(w http.ResponseWriter, r *http.Request) {
-		s.with(w, r, func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Content-Type", "application/json")
-			if !s.discord.Enabled {
-				http.Error(w, "discord SSO disabled", http.StatusNotImplemented)
-				return
-			}
-			if !assented(r) {
-				http.Error(w, "third-party assent required (set header X-GC-3P-Assent: 1)", http.StatusPreconditionFailed)
-				return
-			}
-			state := randHex(24)
-			url := "https://discord.com/api/oauth2/authorize" +
-				"?response_type=code" +
-				"&client_id=" + urlq(s.discord.ClientID) +
-				"&scope=" + urlq("identify") +
-				"&redirect_uri=" + urlq(s.discord.RedirectURI) +
-				"&prompt=consent" +
-				"&state=" + urlq(state)
-			_ = json.NewEncoder(w).Encode(map[string]any{"url": url, "note": "We cannot vouch for external IdP security."})
-		})
-	})
-
-	// Callback: exchanges code for Discord access_token, fetches @me to get subject id
-	// then issues a short-lived shard token (HMAC). No data persisted.
-	s.mux.HandleFunc("/v1/auth/discord/callback", func(w http.ResponseWriter, r *http.Request) {
-		s.with(w, r, func(w http.ResponseWriter, r *http.Request) {
-			w.Header().Set("Content-Type", "application/json")
-			if !s.discord.Enabled {
-				http.Error(w, "discord SSO disabled", http.StatusNotImplemented)
-				return
-			}
-			if !assented(r) {
-				http.Error(w, "third-party assent required (set header X-GC-3P-Assent: 1)", http.StatusPreconditionFailed)
-				return
-			}
-			code := r.URL.Query().Get("code")
-			if code == "" {
-				http.Error(w, "missing code", 400)
-				return
-			}
-
-			form := "client_id=" + urlq(s.discord.ClientID) +
-				"&client_secret=" + urlq(s.discord.ClientSecret) +
-				"&grant_type=authorization_code" +
-				"&code=" + urlq(code) +
-				"&redirect_uri=" + urlq(s.discord.RedirectURI)
-			req, _ := http.NewRequest(http.MethodPost, "https://discord.com/api/oauth2/token", strings.NewReader(form))
-			req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
-			resp, err := http.DefaultClient.Do(req)
-			if err != nil {
-				http.Error(w, "token exchange failed", 502)
-				return
-			}
-			defer resp.Body.Close()
-			var tok struct {
-				AccessToken string `json:"access_token"`
-				TokenType   string `json:"token_type"`
-			}
-			if err := json.NewDecoder(resp.Body).Decode(&tok); err != nil || tok.AccessToken == "" {
-				http.Error(w, "invalid token response", 502)
-				return
-			}
-
-			uReq, _ := http.NewRequest(http.MethodGet, "https://discord.com/api/users/@me", nil)
-			uReq.Header.Set("Authorization", tok.TokenType+" "+tok.AccessToken)
-			uResp, err := http.DefaultClient.Do(uReq)
-			if err != nil {
-				http.Error(w, "userinfo failed", 502)
-				return
-			}
-			defer uResp.Body.Close()
-			var me struct {
-				ID string `json:"id"`
-			}
-			if err := json.NewDecoder(uResp.Body).Decode(&me); err != nil || me.ID == "" {
-				http.Error(w, "userinfo parse failed", 502)
-				return
-			}
-
-			exp := time.Now().UTC().Add(30 * time.Minute)
-			gcTok, err := s.signShardToken("discord", me.ID, exp)
-			if err != nil {
-				http.Error(w, err.Error(), 500)
-				return
-			}
-
-			_ = json.NewEncoder(w).Encode(map[string]any{
-				"ok":         true,
-				"token":      gcTok,
-				"expires_at": exp.Format(time.RFC3339),
-				"disclaimer": "This token is issued after authenticating with a third-party provider (Discord). We cannot vouch for third-party security.",
-			})
-		})
 	})
 }
 
-// ---------- misc helpers ----------
+// ---- Small utils ----
 
-func assented(r *http.Request) bool {
+func ReadAllStrict(r io.Reader, max int64) ([]byte, error) {
-	if r.Header.Get("X-GC-3P-Assent") == "1" {
+	if max <= 0 {
-		return true
+		return io.ReadAll(r)
 	}
-	if r.URL.Query().Get("assent") == "1" {
+	lr := io.LimitedReader{R: r, N: max + 1}
-		return true
+	b, err := io.ReadAll(&lr)
-	}
-	return false
-}
-
-func (s *Server) nowCoarse() string {
-	ts := time.Now().UTC()
-	if s.coarseTS {
-		ts = ts.Truncate(time.Hour)
-	}
-	return ts.Format(time.RFC3339)
-}
-
-func (s *Server) parseRFC3339(v string) time.Time {
-	t, _ := time.Parse(time.RFC3339, v)
-	return t
-}
-
-// ----- listeners -----
-
-func (s *Server) ListenHTTP(addr string) error {
-	log.Printf("http listening on %s", addr)
-	server := &http.Server{
-		Addr:              addr,
-		Handler:           s.mux,
-		ReadHeaderTimeout: 5 * time.Second,
-	}
-	ln, err := net.Listen("tcp", addr)
 	if err != nil {
-		return err
+		return nil, err
 	}
-	return server.Serve(ln)
+	if int64(len(b)) > max {
+		return nil, errors.New("payload too large")
+	}
+	return b, nil
 }
 
-func (s *Server) ListenHTTPS(addr, certFile, keyFile string) error {
+func maxObjectBytes() int64 {
-	log.Printf("https listening on %s", addr)
+	v := strings.TrimSpace(os.Getenv("GC_MAX_OBJECT_KB"))
-	server := &http.Server{
+	if v == "" {
-		Addr:              addr,
+		return 256 * 1024 // default 256 KiB
-		Handler:           s.mux,
-		ReadHeaderTimeout: 5 * time.Second,
 	}
-	return server.ListenAndServeTLS(certFile, keyFile)
+	n, err := strconv.Atoi(v)
+	if err != nil || n <= 0 {
+		return 256 * 1024
+	}
+	return int64(n) * 1024
 }
 
-func (s *Server) ListenMTLS(addr string, tlsCfg *tls.Config) error {
+// ---- Basic endpoints ----
-	log.Printf("federation mTLS listening on %s", addr)
+
-	server := &http.Server{
+func (s *Server) healthz(w http.ResponseWriter, r *http.Request) {
-		Addr:              addr,
+	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
-		Handler:           s.mux,
+	_, _ = w.Write([]byte("ok"))
-		ReadHeaderTimeout: 5 * time.Second,
+}
-		TLSConfig:         tlsCfg,
+
+type caps struct {
+	AllowAnonPlaintext bool `json:"allow_anon_plaintext"`
+	ZeroTrust          bool `json:"zero_trust"`
+}
+
+func (s *Server) handleCaps(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(caps{
+		AllowAnonPlaintext: s.allowAnonPlaintext,
+		ZeroTrust:          true,
+	})
+}
+
+// ---- Object handlers ----
+
+type putResp struct {
+	Hash     string    `json:"hash"`
+	Bytes    int64     `json:"bytes"`
+	StoredAt time.Time `json:"stored_at"`
+	Private  bool      `json:"private"`
+}
+
+func (s *Server) handlePutObject(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodPut {
+		http.NotFound(w, r)
+		return
 	}
-	ln, err := tls.Listen("tcp", addr, tlsCfg)
+	private := r.Header.Get("X-GC-Private") == "1"
+
+	// Strict read (prevents runaway memory and surfaces clear error)
+	data, err := ReadAllStrict(r.Body, maxObjectBytes())
 	if err != nil {
-		return err
+		log.Printf("PUT /v1/object read error: %v", err)
+		http.Error(w, "bad request: "+err.Error(), http.StatusBadRequest)
+		return
 	}
-	return server.Serve(ln)
+
+	// Store
+	hash, n, storedAt, err := s.store.Put(bytes.NewReader(data), private)
+	if err != nil {
+		log.Printf("PUT /v1/object store error: %v", err)
+		http.Error(w, "store failed: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	// Broadcast SSE "put"
+	s.broadcastEvent("put", map[string]any{
+		"hash":      hash,
+		"bytes":     n,
+		"stored_at": storedAt.UTC(),
+		"private":   private,
+	})
+
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(putResp{
+		Hash:     hash,
+		Bytes:    n,
+		StoredAt: storedAt.UTC(),
+		Private:  private,
+	})
+}
+
+func (s *Server) handleObjectByHash(w http.ResponseWriter, r *http.Request) {
+	seg := strings.TrimPrefix(r.URL.Path, "/v1/object")
+	seg = strings.TrimPrefix(seg, "/")
+	if seg == "" {
+		http.NotFound(w, r)
+		return
+	}
+	hash := path.Clean(seg)
+	switch r.Method {
+	case http.MethodGet:
+		rc, n, err := s.store.Get(hash)
+		if err != nil {
+			http.Error(w, "not found", http.StatusNotFound)
+			return
+		}
+		defer rc.Close()
+		w.Header().Set("Content-Type", "application/octet-stream")
+		w.Header().Set("Content-Length", fmt.Sprintf("%d", n))
+		if _, err := io.Copy(w, rc); err != nil {
+			return
+		}
+	case http.MethodDelete:
+		if err := s.store.Delete(hash); err != nil {
+			http.Error(w, "not found", http.StatusNotFound)
+			return
+		}
+		s.broadcastEvent("delete", map[string]any{"hash": hash})
+		w.WriteHeader(http.StatusNoContent)
+	default:
+		http.NotFound(w, r)
+	}
+}
+
+// ---- Index handlers ----
+
+type indexEntry struct {
+	Hash     string    `json:"hash"`
+	Bytes    int64     `json:"bytes"`
+	Private  bool      `json:"private"`
+	StoredAt time.Time `json:"stored_at"`
+}
+
+func (s *Server) handleIndex(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.NotFound(w, r)
+		return
+	}
+	out := make([]indexEntry, 0, 256)
+	_, err := s.store.Walk(func(hash string, bytes int64, private bool, storedAt time.Time) error {
+		out = append(out, indexEntry{
+			Hash:     hash,
+			Bytes:    bytes,
+			Private:  private,
+			StoredAt: storedAt.UTC(),
+		})
+		return nil
+	})
+	if err != nil {
+		http.Error(w, "index walk failed: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+	sortByStoredAtDesc(out)
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	_ = json.NewEncoder(w).Encode(out)
+}
+
+func sortByStoredAtDesc(a []indexEntry) {
+	for i := 1; i < len(a); i++ {
+		j := i
+		for j > 0 && a[j].StoredAt.After(a[j-1].StoredAt) {
+			a[j], a[j-1] = a[j-1], a[j]
+			j--
+		}
+	}
+}
+
+// ---- SSE ----
+
+func (s *Server) handleIndexStream(w http.ResponseWriter, r *http.Request) {
+	if r.Method != http.MethodGet {
+		http.NotFound(w, r)
+		return
+	}
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "stream unsupported", http.StatusInternalServerError)
+		return
+	}
+
+	ch := make(chan []byte, 32)
+	s.addSub(ch)
+	defer s.removeSub(ch)
+
+	_, _ = io.WriteString(w, ": ok\n\n")
+	flusher.Flush()
+
+	notify := r.Context().Done()
+	hb := time.NewTicker(20 * time.Second)
+	defer hb.Stop()
+
+	for {
+		select {
+		case <-notify:
+			return
+		case <-hb.C:
+			_, _ = io.WriteString(w, ": ping\n\n")
+			flusher.Flush()
+		case msg := <-ch:
+			_, _ = io.WriteString(w, "data: ")
+			_, _ = w.Write(msg)
+			_, _ = io.WriteString(w, "\n\n")
+			flusher.Flush()
+		}
+	}
+}
+
+func (s *Server) addSub(ch chan []byte) {
+	s.sseMu.Lock()
+	s.sseSubs[ch] = struct{}{}
+	s.sseMu.Unlock()
+}
+
+func (s *Server) removeSub(ch chan []byte) {
+	s.sseMu.Lock()
+	delete(s.sseSubs, ch)
+	close(ch)
+	s.sseMu.Unlock()
+}
+
+func (s *Server) broadcastEvent(ev string, payload any) {
+	body, _ := json.Marshal(map[string]any{"event": ev, "data": payload})
+	s.sseMu.Lock()
+	for ch := range s.sseSubs {
+		select {
+		case ch <- body:
+		default:
+		}
+	}
+	s.sseMu.Unlock()
+}
+
+// ---- Helpers ----
+
+func bufioReader(r io.Reader) *bufio.Reader {
+	if br, ok := r.(*bufio.Reader); ok {
+		return br
+	}
+	return bufio.NewReader(r)
 }

internal/api/ratelimit.go

@@ -0,0 +1,72 @@
+package api
+
+import (
+	"sync"
+	"time"
+)
+
+// Simple token-bucket rate limiter used by Server.cors middleware.
+
+type tokenBucket struct {
+	tokens   float64
+	lastFill time.Time
+}
+
+type rateLimiter struct {
+	rate     float64 // tokens per second
+	burst    float64
+	mu       sync.Mutex
+	bk       map[string]*tokenBucket
+	evictDur time.Duration
+	lastGC   time.Time
+}
+
+func newRateLimiter(rate float64, burst int, evict time.Duration) *rateLimiter {
+	return &rateLimiter{
+		rate:     rate,
+		burst:    float64(burst),
+		bk:       make(map[string]*tokenBucket),
+		evictDur: evict,
+		lastGC:   time.Now(),
+	}
+}
+
+func (rl *rateLimiter) allow(key string) bool {
+	now := time.Now()
+	rl.mu.Lock()
+	defer rl.mu.Unlock()
+
+	// GC old buckets occasionally
+	if now.Sub(rl.lastGC) > rl.evictDur {
+		for k, b := range rl.bk {
+			if now.Sub(b.lastFill) > rl.evictDur {
+				delete(rl.bk, k)
+			}
+		}
+		rl.lastGC = now
+	}
+
+	b, ok := rl.bk[key]
+	if !ok {
+		b = &tokenBucket{tokens: rl.burst, lastFill: now}
+		rl.bk[key] = b
+	}
+
+	// Refill
+	elapsed := now.Sub(b.lastFill).Seconds()
+	b.tokens = minf(rl.burst, b.tokens+elapsed*rl.rate)
+	b.lastFill = now
+
+	if b.tokens >= 1.0 {
+		b.tokens -= 1.0
+		return true
+	}
+	return false
+}
+
+func minf(a, b float64) float64 {
+	if a < b {
+		return a
+	}
+	return b
+}

internal/api/static.go

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"log"
 	"net/http"
 	"os"
 	"path/filepath"
@@ -9,63 +8,69 @@ import (
 	"time"
 )
 
-// Mount static on the API mux (kept for compatibility; still serves under API port if you want)
+// ListenFrontend serves the static client from s.StaticDir on a separate port (e.g. :9082).
-func (s *Server) MountStatic(dir string, baseURL string) {
+func (s *Server) ListenFrontend(addr string) error {
-	if dir == "" {
+	root := s.StaticDir
-		return
+	if root == "" {
+		root = "./client"
 	}
-	if baseURL == "" {
+	// Basic security/CSP headers for static content.
-		baseURL = "/"
+	addCommonHeaders := func(w http.ResponseWriter) {
+		// CORS: static site can be embedded by any origin if you want, keep strict by default
+		w.Header().Set("Access-Control-Allow-Origin", "*")
+		w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
+		w.Header().Set("Cross-Origin-Resource-Policy", "same-site")
+		w.Header().Set("Referrer-Policy", "no-referrer")
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+		w.Header().Set("X-Frame-Options", "DENY")
+		// Cache: avoid caching during test
+		w.Header().Set("Cache-Control", "no-store")
+		// CSP: no inline scripts/styles; allow XHR/SSE/Ws to any (tunnel/api) host
+		w.Header().Set("Content-Security-Policy",
+			strings.Join([]string{
+				"default-src 'self'",
+				"script-src 'self'",
+				"style-src 'self'",
+				"img-src 'self' data:",
+				"font-src 'self'",
+				"connect-src *",
+				"frame-ancestors 'none'",
+				"base-uri 'self'",
+				"form-action 'self'",
+			}, "; "),
+		)
 	}
-	s.mux.Handle(baseURL, s.staticHandler(dir, baseURL))
-	if !strings.HasSuffix(baseURL, "/") {
-		s.mux.Handle(baseURL+"/", s.staticHandler(dir, baseURL))
-	}
-}
 
-// NEW: serve the same static handler on its own port (frontend).
+	// File handler with index.html fallback for “/”.
-func (s *Server) ListenFrontendHTTP(addr, dir, baseURL string) error {
+	fileServer := http.FileServer(http.Dir(root))
-	if dir == "" || addr == "" {
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		return nil
+		addCommonHeaders(w)
-	}
+
-	log.Printf("frontend listening on %s (dir=%s base=%s)", addr, dir, baseURL)
+		// Serve index.html at root or when requesting a directory.
-	mx := http.NewServeMux()
+		p := r.URL.Path
-	mx.Handle(baseURL, s.staticHandler(dir, baseURL))
+		if p == "/" || p == "" {
-	if !strings.HasSuffix(baseURL, "/") {
+			http.ServeFile(w, r, filepath.Join(root, "index.html"))
-		mx.Handle(baseURL+"/", s.staticHandler(dir, baseURL))
+			return
-	}
+		}
-	server := &http.Server{
+
+		// If path maps to a directory, try its index.html.
+		full := filepath.Join(root, filepath.Clean(strings.TrimPrefix(p, "/")))
+		if st, err := os.Stat(full); err == nil && st.IsDir() {
+			indexFile := filepath.Join(full, "index.html")
+			if _, err := os.Stat(indexFile); err == nil {
+				http.ServeFile(w, r, indexFile)
+				return
+			}
+		}
+
+		// Normal static file.
+		fileServer.ServeHTTP(w, r)
+	})
+
+	srv := &http.Server{
 		Addr:              addr,
-		Handler:           mx,
+		Handler:           handler,
 		ReadHeaderTimeout: 5 * time.Second,
 	}
-	return server.ListenAndServe()
+	return srv.ListenAndServe()
-}
-
-func (s *Server) staticHandler(dir, baseURL string) http.Handler {
-	if baseURL == "" {
-		baseURL = "/"
-	}
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		s.secureHeaders(w)
-		up := strings.TrimPrefix(r.URL.Path, baseURL)
-		if up == "" || strings.HasSuffix(r.URL.Path, "/") {
-			up = "index.html"
-		}
-		full := filepath.Join(dir, filepath.FromSlash(up))
-		if !strings.HasPrefix(filepath.Clean(full), filepath.Clean(dir)) {
-			http.NotFound(w, r)
-			return
-		}
-		if st, err := os.Stat(full); err == nil && !st.IsDir() {
-			http.ServeFile(w, r, full)
-			return
-		}
-		fallback := filepath.Join(dir, "index.html")
-		if _, err := os.Stat(fallback); err == nil {
-			http.ServeFile(w, r, fallback)
-			return
-		}
-		http.NotFound(w, r)
-	})
 }

internal/auth/gc2.go

@@ -0,0 +1,78 @@
+package auth
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"strings"
+	"time"
+)
+
+type Claims struct {
+	Sub string `json:"sub"`           // account ID (acc_…)
+	Exp int64  `json:"exp"`           // unix seconds
+	Nbf int64  `json:"nbf,omitempty"` // not before
+	Iss string `json:"iss,omitempty"` // greencoast
+	Aud string `json:"aud,omitempty"` // api
+	Jti string `json:"jti,omitempty"` // token id (optional)
+	CNF string `json:"cnf,omitempty"` // key binding: "p256:<b64raw>" or "ed25519:<b64raw>"
+}
+
+func MintGC2(signKey []byte, c Claims) (string, error) {
+	if len(signKey) == 0 {
+		return "", errors.New("sign key missing")
+	}
+	if c.Sub == "" || c.Exp == 0 {
+		return "", errors.New("claims incomplete")
+	}
+	body, _ := json.Marshal(c)
+	mac := hmac.New(sha256.New, signKey)
+	mac.Write(body)
+	sig := mac.Sum(nil)
+	return "gc2." + base64.RawURLEncoding.EncodeToString(body) + "." + base64.RawURLEncoding.EncodeToString(sig), nil
+}
+
+func VerifyGC2(signKey []byte, tok string, now time.Time) (Claims, error) {
+	var zero Claims
+	if !strings.HasPrefix(tok, "gc2.") {
+		return zero, errors.New("bad prefix")
+	}
+	parts := strings.Split(tok, ".")
+	if len(parts) != 3 {
+		return zero, errors.New("bad parts")
+	}
+	body, err := base64.RawURLEncoding.DecodeString(parts[1])
+	if err != nil {
+		return zero, err
+	}
+	want, err := base64.RawURLEncoding.DecodeString(parts[2])
+	if err != nil {
+		return zero, err
+	}
+	mac := hmac.New(sha256.New, signKey)
+	mac.Write(body)
+	if !hmac.Equal(want, mac.Sum(nil)) {
+		return zero, errors.New("bad sig")
+	}
+	var c Claims
+	if err := json.Unmarshal(body, &c); err != nil {
+		return zero, err
+	}
+	t := now.Unix()
+	if c.Nbf != 0 && t < c.Nbf {
+		return zero, errors.New("nbf")
+	}
+	if t > c.Exp {
+		return zero, errors.New("expired")
+	}
+	return c, nil
+}
+
+func AccountIDFromPub(raw []byte) string {
+	// acc_<first32 hex of sha256(pub)>
+	sum := sha256.Sum256(raw)
+	return "acc_" + hex.EncodeToString(sum[:16])
+}

internal/index/index.go

@@ -1,123 +1,49 @@
 package index
 
 import (
-	"bufio"
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"sort"
 	"sync"
-	"time"
 )
 
-type opType string
+// Entry is the index record returned to clients.
-
+// Keep metadata minimal to protect users.
-const (
-	OpPut opType = "put"
-	OpDel opType = "del"
-)
-
-type record struct {
-	Op       opType    `json:"op"`
-	Hash     string    `json:"hash"`
-	Bytes    int64     `json:"bytes,omitempty"`
-	StoredAt time.Time `json:"stored_at,omitempty"`
-	Private  bool      `json:"private,omitempty"`
-}
-
 type Entry struct {
-	Hash     string    `json:"hash"`
+	Hash      string `json:"hash"`
-	Bytes    int64     `json:"bytes"`
+	Bytes     int64  `json:"bytes"`
-	StoredAt time.Time `json:"stored_at"`
+	StoredAt  string `json:"stored_at"` // RFC3339Nano string
-	Private  bool      `json:"private"`
+	Private   bool   `json:"private"`
+	CreatorTZ string `json:"creator_tz,omitempty"`
+	Author    string `json:"author,omitempty"` // pseudonymous (thumbprint), optional
 }
 
 type Index struct {
-	path string
+	mu   sync.RWMutex
-	mu   sync.Mutex
+	data map[string]Entry
 }
 
-func New(baseDir string) *Index {
+func New() *Index {
-	return &Index{path: filepath.Join(baseDir, "index.jsonl")}
+	return &Index{data: make(map[string]Entry)}
 }
 
-func (i *Index) AppendPut(e Entry) error {
+func (ix *Index) Put(e Entry) error {
-	i.mu.Lock()
+	ix.mu.Lock()
-	defer i.mu.Unlock()
+	ix.data[e.Hash] = e
-	return appendRec(i.path, record{
+	ix.mu.Unlock()
-		Op:       OpPut,
+	return nil
-		Hash:     e.Hash,
-		Bytes:    e.Bytes,
-		StoredAt: e.StoredAt,
-		Private:  e.Private,
-	})
 }
 
-func (i *Index) AppendDelete(hash string) error {
+func (ix *Index) Delete(hash string) error {
-	i.mu.Lock()
+	ix.mu.Lock()
-	defer i.mu.Unlock()
+	delete(ix.data, hash)
-	return appendRec(i.path, record{Op: OpDel, Hash: hash})
+	ix.mu.Unlock()
+	return nil
 }
 
-func appendRec(path string, r record) error {
+func (ix *Index) All() []Entry {
-	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+	ix.mu.RLock()
-		return err
+	out := make([]Entry, 0, len(ix.data))
+	for _, e := range ix.data {
+		out = append(out, e)
 	}
-	f, err := os.OpenFile(path, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0o644)
+	ix.mu.RUnlock()
-	if err != nil {
+	return out
-		return err
-	}
-	defer f.Close()
-	enc := json.NewEncoder(f)
-	return enc.Encode(r)
-}
-
-func (i *Index) Snapshot() ([]Entry, error) {
-	i.mu.Lock()
-	defer i.mu.Unlock()
-
-	f, err := os.Open(i.path)
-	if os.IsNotExist(err) {
-		return nil, nil
-	}
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	sc := bufio.NewScanner(f)
-	sc.Buffer(make([]byte, 0, 64*1024), 4*1024*1024)
-
-	type state struct {
-		Entry   Entry
-		Deleted bool
-	}
-	m := make(map[string]state)
-	for sc.Scan() {
-		var rec record
-		if err := json.Unmarshal(sc.Bytes(), &rec); err != nil {
-			continue
-		}
-		switch rec.Op {
-		case OpPut:
-			m[rec.Hash] = state{Entry: Entry{
-				Hash: rec.Hash, Bytes: rec.Bytes, StoredAt: rec.StoredAt, Private: rec.Private,
-			}}
-		case OpDel:
-			s := m[rec.Hash]
-			s.Deleted = true
-			m[rec.Hash] = s
-		}
-	}
-	if err := sc.Err(); err != nil {
-		return nil, err
-	}
-	var out []Entry
-	for _, s := range m {
-		if !s.Deleted && s.Entry.Hash != "" {
-			out = append(out, s.Entry)
-		}
-	}
-	sort.Slice(out, func(i, j int) bool { return out[i].StoredAt.After(out[j].StoredAt) })
-	return out, nil
 }

internal/storage/fs.go

@@ -0,0 +1,151 @@
+package api
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+)
+
+// SimpleFSStore is a minimal FS-backed implementation of BlobStore.
+// Layout under root:
+//
+//	<root>/<hash>        - content
+//	<root>/<hash>.priv   - presence means "private"
+type SimpleFSStore struct {
+	root string
+}
+
+func NewSimpleFSStore(root string) *SimpleFSStore {
+	return &SimpleFSStore{root: root}
+}
+
+func (fs *SimpleFSStore) ensureRoot() error {
+	return os.MkdirAll(fs.root, 0o755)
+}
+
+func (fs *SimpleFSStore) pathFor(hash string) string {
+	return filepath.Join(fs.root, hash)
+}
+func (fs *SimpleFSStore) privPathFor(hash string) string {
+	return filepath.Join(fs.root, hash+".priv")
+}
+
+// Get implements BlobStore.Get
+func (fs *SimpleFSStore) Get(hash string) (io.ReadCloser, int64, error) {
+	if err := fs.ensureRoot(); err != nil {
+		return nil, 0, err
+	}
+	f, err := os.Open(fs.pathFor(hash))
+	if err != nil {
+		return nil, 0, err
+	}
+	st, err := f.Stat()
+	if err != nil {
+		_ = f.Close()
+		return nil, 0, err
+	}
+	return f, st.Size(), nil
+}
+
+// Put implements BlobStore.Put
+func (fs *SimpleFSStore) Put(r io.Reader, private bool) (string, int64, time.Time, error) {
+	if err := fs.ensureRoot(); err != nil {
+		return "", 0, time.Time{}, err
+	}
+	tmp, err := os.CreateTemp(fs.root, "put-*")
+	if err != nil {
+		return "", 0, time.Time{}, err
+	}
+	defer func() {
+		_ = tmp.Close()
+		_ = os.Remove(tmp.Name())
+	}()
+
+	h := sha256.New()
+	w := io.MultiWriter(tmp, h)
+
+	n, err := io.Copy(w, r)
+	if err != nil {
+		return "", 0, time.Time{}, err
+	}
+	hash := hex.EncodeToString(h.Sum(nil))
+
+	final := fs.pathFor(hash)
+	if err := os.Rename(tmp.Name(), final); err != nil {
+		return "", 0, time.Time{}, err
+	}
+
+	if private {
+		if err := os.WriteFile(fs.privPathFor(hash), nil, 0o600); err != nil {
+			_ = os.Remove(final)
+			return "", 0, time.Time{}, err
+		}
+	}
+
+	st, err := os.Stat(final)
+	if err != nil {
+		return "", 0, time.Time{}, err
+	}
+	return hash, n, st.ModTime().UTC(), nil
+}
+
+// Delete implements BlobStore.Delete
+func (fs *SimpleFSStore) Delete(hash string) error {
+	if err := fs.ensureRoot(); err != nil {
+		return err
+	}
+	_ = os.Remove(fs.privPathFor(hash))
+	return os.Remove(fs.pathFor(hash))
+}
+
+// Walk implements BlobStore.Walk
+func (fs *SimpleFSStore) Walk(fn func(hash string, bytes int64, private bool, storedAt time.Time) error) (int, error) {
+	if err := fs.ensureRoot(); err != nil {
+		return 0, err
+	}
+	ents, err := os.ReadDir(fs.root)
+	if err != nil {
+		return 0, err
+	}
+	count := 0
+	for _, e := range ents {
+		if e.IsDir() {
+			continue
+		}
+		name := e.Name()
+		// skip sidecars and non-64-hex filenames
+		if strings.HasSuffix(name, ".priv") || len(name) != 64 || !isHex(name) {
+			continue
+		}
+		full := fs.pathFor(name)
+		st, err := os.Stat(full)
+		if err != nil {
+			continue
+		}
+		private := false
+		if _, err := os.Stat(fs.privPathFor(name)); err == nil {
+			private = true
+		}
+		if err := fn(name, st.Size(), private, st.ModTime().UTC()); err != nil {
+			return count, err
+		}
+		count++
+	}
+	return count, nil
+}
+
+func isHex(s string) bool {
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if !((c >= '0' && c <= '9') ||
+			(c >= 'a' && c <= 'f') ||
+			(c >= 'A' && c <= 'F')) {
+			return false
+		}
+	}
+	return true
+}

internal/storage/fsstore.go

@@ -1,95 +0,0 @@
-package storage
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-)
-
-type FSStore struct {
-	root       string
-	maxObjectB int64
-}
-
-func NewFSStore(root string, maxKB int) (*FSStore, error) {
-	if root == "" {
-		root = "./data/objects"
-	}
-	if err := os.MkdirAll(root, 0o755); err != nil {
-		return nil, err
-	}
-	return &FSStore{root: root, maxObjectB: int64(maxKB) * 1024}, nil
-}
-
-func (s *FSStore) Put(r io.Reader) (string, int64, error) {
-	h := sha256.New()
-	tmp := filepath.Join(s.root, ".tmp")
-	_ = os.MkdirAll(tmp, 0o755)
-	f, err := os.CreateTemp(tmp, "obj-*")
-	if err != nil {
-		return "", 0, err
-	}
-	defer f.Close()
-
-	var n int64
-	buf := make([]byte, 32*1024)
-	for {
-		m, er := r.Read(buf)
-		if m > 0 {
-			n += int64(m)
-			if s.maxObjectB > 0 && n > s.maxObjectB {
-				return "", 0, errors.New("object too large")
-			}
-			_, _ = h.Write(buf[:m])
-			if _, werr := f.Write(buf[:m]); werr != nil {
-				return "", 0, werr
-			}
-		}
-		if er == io.EOF {
-			break
-		}
-		if er != nil {
-			return "", 0, er
-		}
-	}
-	sum := hex.EncodeToString(h.Sum(nil))
-	dst := filepath.Join(s.root, sum[:2], sum[2:4], sum)
-	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
-		return "", 0, err
-	}
-	if err := os.Rename(f.Name(), dst); err != nil {
-		return "", 0, err
-	}
-	return sum, n, nil
-}
-
-func (s *FSStore) pathFor(hash string) string {
-	return filepath.Join(s.root, hash[:2], hash[2:4], hash)
-}
-
-func (s *FSStore) Get(hash string) (string, error) {
-	if len(hash) < 4 {
-		return "", os.ErrNotExist
-	}
-	p := s.pathFor(hash)
-	if _, err := os.Stat(p); err != nil {
-		return "", err
-	}
-	return p, nil
-}
-
-func (s *FSStore) Delete(hash string) error {
-	if len(hash) < 4 {
-		return os.ErrNotExist
-	}
-	p := s.pathFor(hash)
-	if err := os.Remove(p); err != nil {
-		return err
-	}
-	_ = os.Remove(filepath.Dir(p))
-	_ = os.Remove(filepath.Dir(filepath.Dir(p)))
-	return nil
-}

testdata/index.jsonl

@@ -0,0 +1,4 @@
+{"op":"put","hash":"a008a13ade86edbd77f5c0fcfcf35bd295c93069be42fdbd46bc65b392ddf5fb","bytes":110,"stored_at":"2025-08-22T03:00:00Z"}
+{"op":"put","hash":"9628e2adcd7a5e820fbdbe075027ac0ad78ef1a7a501971c2048bc5e5436b891","bytes":105,"stored_at":"2025-08-22T03:00:00Z","private":true}
+{"op":"put","hash":"6a166437b9988bd11e911375f3ca1b4cd10b7db9a32812409c6d79a0753dd973","bytes":98,"stored_at":"2025-08-22T03:00:00Z"}
+{"op":"put","hash":"f452402fadb6608bd6f9b613a1d58234e2135f045ea29262574e3e4b1e5f7292","bytes":46,"stored_at":"2025-08-22T03:00:00Z"}