fedipod-server 0.28.1 → 0.30.0

package/web/app/pod-auth.mjs

@@ -1,248 +0,0 @@
-// pod-auth.mjs — the pod side of sign-in, done in the browser with no server
-// in between. It is the browser-native twin of lib/account.mjs and
-// vendor/idp-grant.cjs: create a Community Solid Server account and pod, mint a
-// client credential, and turn that credential into a DPoP-bound session whose
-// fetch writes to the pod. Everything a Node agent did against a CSS account
-// API, a page does here — proven cross-origin against solidcommunity.net on
-// 2026-09-06 (claude/validation/scn-cross-origin-spike.html).
-//
-// No dependency on lib/: lib is Node (node:crypto, undici, @fedify). This uses
-// only WebCrypto and fetch, so it runs in a tab and in a service worker.
-
-const b64u = (buf) => btoa(String.fromCharCode(...new Uint8Array(buf)))
-  .replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-const enc = (o) => b64u(new TextEncoder().encode(JSON.stringify(o)));
-const sha256 = async (str) => crypto.subtle.digest('SHA-256', new TextEncoder().encode(str));
-
-// A CSS account-API call: JSON in, JSON out, the account token carried the way
-// CSS wants it (a bearer with its own scheme, not a cookie, in v7).
-async function accountFetch(url, { method = 'GET', body, token } = {}) {
-  const headers = { accept: 'application/json' };
-  if (body !== undefined) headers['content-type'] = 'application/json';
-  if (token) headers.authorization = `CSS-Account-Token ${token}`;
-  const res = await fetch(url, { method, headers, body: body === undefined ? undefined : JSON.stringify(body) });
-  let json = null;
-  try { json = await res.json(); } catch { /* non-JSON error bodies exist */ }
-  return { status: res.status, json };
-}
-
-/** Is this origin a CSS v7 account API at all? Cheap pre-flight for the form. */
-export async function accountApiControls(issuer) {
-  const origin = issuer.replace(/\/+$/, '');
-  const { status, json } = await accountFetch(`${origin}/.account/`);
-  if (status >= 400 || !json?.controls) return null;
-  return json.controls;
-}
-
-/**
- * Create an account and a pod named `podName`. Idempotent on re-run: an
- * existing account logs in, an existing pod of the same name is reused. Refuses
- * to make a second pod on an account that already has one, which would give it
- * a second WebID a single credential could not match. Mirrors
- * lib/account.mjs's guards exactly, because the failure it prevents (a
- * credential bound to the wrong WebID that 403s every write) is the same here.
- */
-export async function createAccountWithPod({ issuer, email, password, podName }) {
-  const origin = issuer.replace(/\/+$/, '');
-  const accountRoot = `${origin}/.account/`;
-
-  let token;
-  const login = await accountFetch(`${accountRoot}login/password/`, { method: 'POST', body: { email, password } });
-  if (login.status < 400 && login.json?.authorization) {
-    token = login.json.authorization;
-  } else {
-    const create = await accountFetch(`${accountRoot}account/`, { method: 'POST' });
-    if (!create.json?.authorization) {
-      throw new Error(`could not create an account at ${origin} (HTTP ${create.status})`
-        + ` — is sign-up open there? ${create.json?.message || ''}`);
-    }
-    token = create.json.authorization;
-    const pwCreate = (await accountFetch(accountRoot, { token })).json?.controls?.password?.create;
-    if (!pwCreate) throw new Error('this server is not a CSS v7 account API (no password control)');
-    const pw = await accountFetch(pwCreate, { method: 'POST', token, body: { email, password } });
-    if (pw.status >= 400) throw new Error(`could not set the password (HTTP ${pw.status}): ${pw.json?.message || ''}`);
-  }
-
-  const podCreate = (await accountFetch(accountRoot, { token })).json?.controls?.account?.pod;
-  if (!podCreate) throw new Error('this server does not offer pod creation through its account API');
-
-  const findOwn = async () => {
-    const pods = (await accountFetch(podCreate, { token })).json?.pods || {};
-    return Object.entries(pods).find(([url]) => {
-      try {
-        const u = new URL(url);
-        return u.hostname === podName || u.hostname.startsWith(`${podName}.`)
-          || u.pathname.split('/').filter(Boolean).includes(podName);
-      } catch { return false; }
-    }) || null;
-  };
-  const owned = Object.keys((await accountFetch(podCreate, { token })).json?.pods || {});
-  if (owned.length && !(await findOwn())) {
-    throw new Error(`${email} already has a pod on ${new URL(origin).host} — one account, one pod.`
-      + ' A second identity needs its own account. Nothing was created.');
-  }
-  const made = await accountFetch(podCreate, { method: 'POST', token, body: { name: podName } });
-  let pod = made.json?.pod || made.json?.podBaseUrl || null;
-  let webId = made.json?.webId || null;
-  if (made.status >= 400 || !pod) {
-    const own = await findOwn();
-    if (own) { pod = own[0]; webId = webId || own[1]?.webId || null; }
-    else if (made.status >= 400) throw new Error(`pod creation failed (HTTP ${made.status}): ${made.json?.message || ''}`);
-  }
-  if (!pod) throw new Error('the server did not report a pod URL');
-  return { pod: pod.endsWith('/') ? pod : pod + '/', webId, accountToken: token };
-}
-
-/**
- * Mint a client credential against the account. `accountToken` reuses a login
- * from createAccountWithPod; otherwise email+password logs in. Returns the
- * credential record the agent expects, minus remotePod (the caller adds it).
- */
-export async function mintCredential({ issuer, email, password, webId, podUrl, accountToken, name = 'fedipod' }) {
-  const origin = issuer.replace(/\/+$/, '');
-  const accountRoot = `${origin}/.account/`;
-
-  let token = accountToken;
-  if (!token) {
-    // Sign in with the identifier the form gave (an email). If that account does
-    // not own the target pod — or the sign-in fails outright — fall back to the
-    // pod's subdomain as a username: older solidcommunity.net accounts sign in by
-    // username, not email. Done behind the scenes so the form only asks for an email.
-    const tryLogin = async (id) => {
-      const r = await accountFetch(`${accountRoot}login/password/`, { method: 'POST', body: { email: id, password } });
-      return (r.status < 400 && r.json?.authorization) ? r.json.authorization : null;
-    };
-    const ownsPod = async (tok) => {
-      if (!podUrl) return true;
-      try {
-        const ctl = (await accountFetch(accountRoot, { token: tok })).json?.controls?.account?.webId;
-        const links = ctl ? (await accountFetch(ctl, { token: tok })).json?.webIdLinks : null;
-        return Object.keys(links || {}).some((w) => new URL(w).origin === new URL(podUrl).origin);
-      } catch { return false; }
-    };
-    token = await tryLogin(email);
-    let sub = null; try { sub = podUrl ? new URL(podUrl).host.split('.')[0] : null; } catch { /* podUrl not a URL */ }
-    if (sub && sub !== email && (!token || !(await ownsPod(token)))) {
-      const alt = await tryLogin(sub);
-      if (alt) token = alt;
-    }
-    if (!token) throw new Error('account login failed — check the email or username and the password');
-  }
-
-  const controls = (await accountFetch(accountRoot, { token })).json?.controls;
-  const ccUrl = controls?.account?.clientCredentials;
-  if (!ccUrl) throw new Error('this server is not a CSS account API (no clientCredentials control)');
-
-  let wid = webId;
-  if (!wid) {
-    const linkCtl = controls?.account?.webId;
-    const links = linkCtl ? (await accountFetch(linkCtl, { token })).json?.webIdLinks : null;
-    const all = links ? Object.keys(links) : [];
-    if (!all.length) throw new Error('no WebID is linked to this account');
-    if (podUrl) {
-      // The credential MUST be for a WebID that owns the target pod, or every
-      // write to it is rejected. Never fall back to an unrelated WebID: a
-      // credential bound to the wrong identity 401s/403s on the pod, which is
-      // the opaque "could not store the key" people then see.
-      let origins = [];
-      try { origins = all.filter((w) => new URL(w).origin === new URL(podUrl).origin); } catch { /* podUrl not a URL */ }
-      if (!origins.length) {
-        throw new Error(`the account you signed in with does not own ${new URL(podUrl).origin}. `
-          + `It is linked to ${all.length} WebID${all.length > 1 ? 's' : ''} — on `
-          + `${all.map((w) => new URL(w).host).join(', ')} — none of them this pod. `
-          + 'Sign in with the account that owns this pod, or let FediPod make you a new one.');
-      }
-      wid = origins[0];
-    } else {
-      wid = all[0];
-    }
-  }
-
-  const made = await accountFetch(ccUrl, { method: 'POST', token, body: { name, webId: wid } });
-  if (made.status >= 400 || !made.json?.secret) throw new Error(`mint failed (HTTP ${made.status}): ${made.json?.message || ''}`);
-  const tokenEndpoint = await discoverTokenEndpoint(origin);
-  return { clientId: made.json.id, secret: made.json.secret, webId: wid, tokenEndpoint,
-    resource: made.json.resource, issuerOrigin: origin,
-    // Carried so sign-up can hand it straight back to revokeCredential. It is a
-    // session token for the ACCOUNT — never stored, never written to the pod,
-    // and gone with the tab.
-    accountToken: token };
-}
-
-/**
- * Delete a client credential.
- *
- * The one sign-up mints is full, permanent access to the pod, and it is needed
- * only while sign-up is running — the agent itself runs on the Solid-OIDC
- * session. Leaving it behind meant every account carried an orphaned key that
- * nothing held and nobody would think to revoke, while the page told the user
- * it was "stored in this browser", which it never was.
- *
- * Best effort by design: a server that will not delete it leaves a credential
- * the owner can still revoke from their pod's own account page, and saying so
- * is better than failing a sign-up that otherwise worked.
- */
-export async function revokeCredential({ resource, accountToken }) {
-  if (!resource || !accountToken) return false;
-  try {
-    const r = await accountFetch(resource, { method: 'DELETE', token: accountToken });
-    return r.status < 400;
-  } catch { return false; }
-}
-
-/** The OIDC token endpoint, from the issuer's discovery document. */
-export async function discoverTokenEndpoint(issuer) {
-  const origin = issuer.replace(/\/+$/, '');
-  try {
-    const res = await fetch(`${origin}/.well-known/openid-configuration`, { headers: { accept: 'application/json' } });
-    if (res.ok) {
-      const doc = await res.json();
-      if (doc.token_endpoint) return doc.token_endpoint;
-    }
-  } catch { /* fall through to the CSS default */ }
-  return `${origin}/.oidc/token`;
-}
-
-/**
- * A DPoP-bound session: one ES256 proof key, a client-credentials access token
- * bound to it, and a `fetch` that signs every request. The same key must sign
- * the token request and every resource request, or the token's binding fails,
- * so the key is made once and kept.
- */
-export async function makeDpopSession({ clientId, secret, tokenEndpoint }) {
-  const proofKey = await crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: 'P-256' }, false, ['sign']);
-  const jwk = await crypto.subtle.exportKey('jwk', proofKey.publicKey);
-  const publicJwk = { kty: jwk.kty, crv: jwk.crv, x: jwk.x, y: jwk.y };
-
-  const proof = async (htm, htu, ath) => {
-    const header = { typ: 'dpop+jwt', alg: 'ES256', jwk: publicJwk };
-    const payload = { htm, htu: htu.split('#')[0], jti: crypto.randomUUID(), iat: Math.floor(Date.now() / 1000), ...(ath ? { ath } : {}) };
-    const data = `${enc(header)}.${enc(payload)}`;
-    const sig = await crypto.subtle.sign({ name: 'ECDSA', hash: 'SHA-256' }, proofKey.privateKey, new TextEncoder().encode(data));
-    return `${data}.${b64u(sig)}`;
-  };
-
-  let token = null; let expiresAt = 0;
-  const refresh = async () => {
-    const basic = btoa(`${encodeURIComponent(clientId)}:${encodeURIComponent(secret)}`);
-    const res = await fetch(tokenEndpoint, {
-      method: 'POST',
-      headers: { authorization: `Basic ${basic}`, 'content-type': 'application/x-www-form-urlencoded', dpop: await proof('POST', tokenEndpoint) },
-      body: 'grant_type=client_credentials&scope=webid',
-    });
-    const tok = await res.json().catch(() => ({}));
-    if (!tok.access_token) throw new Error(`token request failed (HTTP ${res.status}): ${tok.error || ''}`);
-    token = tok.access_token;
-    expiresAt = Date.now() + Math.max(30, (tok.expires_in || 300) - 30) * 1000;
-    return token;
-  };
-
-  const authFetch = async (url, init = {}) => {
-    if (!token || Date.now() > expiresAt) await refresh();
-    const ath = b64u(await sha256(token));
-    const headers = { ...(init.headers || {}), authorization: `DPoP ${token}`, dpop: await proof((init.method || 'GET'), url, ath) };
-    return fetch(url, { ...init, headers });
-  };
-
-  return { fetch: authFetch, refresh };
-}

package/web/app/pod-remote.mjs

@@ -1,84 +0,0 @@
-// pod-remote.mjs — the browser's pod transport, over a DPoP/OIDC session.
-//
-// The conversation with the pod — verbs, ACL documents, the deletion deny-list,
-// the Retry-After cooldown, container listings — is lib/pod/transport.mjs, the
-// same code the Node agent runs. This used to be a hand-kept fork of that file,
-// and the fork had drifted: no cooldown at all for a 429 without a Retry-After
-// header, no byte cap on a listing from a public-Append inbox, a swallowed
-// parse failure, and probes that were neither counted nor held back. Those are
-// gone with the fork.
-//
-// What genuinely differs, and all that is left here: this side retries a
-// dropped connection, and waits a throttle out instead of failing fast.
-
-import { PodTransport } from '../../lib/pod/transport.mjs';
-
-export { protectedFromDeletion } from '../../lib/pod/transport.mjs';
-
-// Retry transient edge throttling (dropped connections, 429/503) with backoff.
-const RETRY_MAX = 5;
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-const backoff = (n) => Math.min(5000, 400 * 2 ** n) + Math.floor(Math.random() * 250);
-
-// A tighter ceiling than the Node side's thirty minutes: a tab is a person
-// waiting, and a hostile or confused header must not park them for half an hour.
-const COOLDOWN_MAX_MS = 5 * 60_000;
-
-export class BrowserRemotePod extends PodTransport {
-  constructor(session, { webId, log = () => {}, role = 'agent' } = {}) {
-    super(session, {
-      webId,
-      log,
-      role,
-      runtime: 'browser',
-      // Wait the throttle out rather than refusing: there is a person here, and
-      // an operation that resumes in four seconds beats one that fails and asks
-      // them to try again.
-      cooldownMode: 'wait',
-      maxCooldownMs: COOLDOWN_MAX_MS,
-    });
-  }
-
-  async warmup() { /* the DPoP session refreshes lazily */ }
-
-  /**
-   * solidcommunity.net sits behind an edge (Cloudflare) that throttles a burst
-   * of requests: during first-boot provisioning the agent makes ~15 rapid
-   * calls, and one comes back as a dropped connection ("Failed to fetch") or a
-   * 429/503. A single dropped write used to abort the whole boot. Retry those
-   * with escalating backoff — the throttle window clears in under a few seconds.
-   * Safe to retry: a thrown request never reached the server, and a 429/503 was
-   * refused, not applied.
-   *
-   * This overrides `_send`, not `fetch`, so it cannot skip the url map, the
-   * cooldown accounting or the deletion deny-list — all of which sit in `fetch`
-   * above it. The pod-wide pause is armed there too, so a retry here waits for
-   * the whole pod rather than each call climbing its own ladder.
-   */
-  async _send(url, init) {
-    let attempt = 0;
-    for (;;) {
-      try {
-        const res = await this.session.fetch(url, init);
-        if ((res.status === 429 || res.status === 503) && attempt < RETRY_MAX) {
-          // Arm the pod-wide pause from THIS answer before retrying. The retry
-          // happens inside `fetch`, so waiting for the outer `_observe` would
-          // mean climbing the whole ladder while ignoring the Retry-After the
-          // server just gave us. `_cooldownGate` then sleeps whatever was
-          // armed; when the server named no delay, nothing is armed and the
-          // backoff below paces it instead.
-          this._observe(res);
-          if (this.pausedUntil > Date.now()) await this._cooldownGate();
-          else await sleep(backoff(attempt));
-          attempt++;
-          continue;
-        }
-        return res;
-      } catch (e) {
-        if (attempt >= RETRY_MAX) throw e;
-        this.log(`[${this.label}] ${init?.method || 'GET'} ${url} failed (${e.message}); retry ${attempt + 1}/${RETRY_MAX}`);
-        await sleep(backoff(attempt++));
-      }
-    }
-  }
-}

package/web/app/shims/_globals.mjs

@@ -1,2 +0,0 @@
-export const URL = globalThis.URL;
-export const URLSearchParams = globalThis.URLSearchParams;

package/web/app/shims/fedify-sig.mjs

@@ -1,77 +0,0 @@
-// fedify-sig.mjs — a browser stand-in for @fedify/fedify/sig.
-//
-// Fedify itself will not run in a browser: it reaches for node:dns, node:net
-// and node:process to resolve and fetch actors. Only two of its functions are
-// on the agent's path:
-//
-//   signRequest       — outbound HTTP Signatures (draft-cavage), what a remote
-//                       server verifies. Implemented here with WebCrypto and
-//                       proven byte-identical to Fedify's own output for the
-//                       same request and key (claude/validation/signing-shim/).
-//   verifyRequestDetailed — inbound verification. The browser agent never runs
-//                       it: it trusts the gateway's receipt, exactly as the
-//                       agent does in the gateway's `trust` mode. Stubbed so a
-//                       bundled import resolves.
-//
-// A browser cannot set Date or Host on a request (both are forbidden header
-// names) and does not add them itself, so a signature that covers them can only
-// travel through the relay, which sends the signed headers verbatim. That is why
-// the real work is `sign()`, which returns the signed headers as data. The
-// browser deliverer hands that to the relay; `signRequest` wraps it into a
-// Request for the Fedify-shaped callers and the byte-equality proof.
-
-const b64 = (buf) => btoa(String.fromCharCode(...new Uint8Array(buf)));
-
-/**
- * Sign a request and return the parts to send: the covered header names, the
- * header values (Date/Host/Digest filled in), the body, and the target. Host is
- * always signed from the URL; the relay's own fetch sends the matching Host.
- */
-export async function sign({ url, method = 'POST', headers = {}, body }, privateKey, keyId) {
-  const u = new URL(url);
-  const m = method.toUpperCase();
-  const signed = {};
-  for (const [k, v] of Object.entries(headers)) {
-    const name = k.toLowerCase();
-    if (name !== 'signature' && name !== 'host') signed[name] = v;
-  }
-
-  let bodyBytes;
-  if (m !== 'GET' && m !== 'HEAD' && body != null) {
-    bodyBytes = typeof body === 'string' ? new TextEncoder().encode(body) : new Uint8Array(body);
-    if (!('digest' in signed)) signed.digest = `SHA-256=${b64(await crypto.subtle.digest('SHA-256', bodyBytes))}`;
-  }
-  if (!('date' in signed)) signed.date = new Date().toUTCString();
-  signed.host = u.host;
-
-  const names = ['(request-target)', ...Object.keys(signed).sort()];
-  const signingString = names.map((n) => (n === '(request-target)'
-    ? `(request-target): ${m.toLowerCase()} ${u.pathname}${u.search}`
-    : `${n}: ${signed[n]}`)).join('\n');
-  const sig = await crypto.subtle.sign('RSASSA-PKCS1-v1_5', privateKey, new TextEncoder().encode(signingString));
-  signed.signature = `keyId="${keyId.href || keyId}",algorithm="rsa-sha256",headers="${names.join(' ')}",signature="${b64(sig)}"`;
-
-  return { url: u.href, method: m, headers: signed, body: bodyBytes ?? null, covered: names };
-}
-
-/** Fedify's signRequest shape: sign, then return a Request. Forbidden headers
- *  (Host, Date) survive here only where the runtime allows them (Node); the
- *  browser delivery path uses sign() and the relay instead. */
-export async function signRequest(request, privateKey, keyId) {
-  const headers = {};
-  for (const [k, v] of request.headers) headers[k] = v;
-  const body = (request.method === 'GET' || request.method === 'HEAD')
-    ? undefined : new Uint8Array(await request.clone().arrayBuffer());
-  const s = await sign({ url: request.url, method: request.method, headers, body }, privateKey, keyId);
-  const out = new Headers();
-  for (const [k, v] of Object.entries(s.headers)) out.set(k, v);
-  const init = { method: s.method, headers: out, signal: request.signal };
-  if (s.body) init.body = s.body;
-  return new Request(request.url, init);
-}
-
-// The browser agent verifies nothing itself — the gateway already did, and its
-// receipt is what the drain trusts. Present so the import resolves.
-export async function verifyRequestDetailed() {
-  return { success: false, reason: 'the browser agent does not verify; it trusts the gateway receipt' };
-}

package/web/app/shims/node-crypto.mjs

@@ -1,113 +0,0 @@
-// node-crypto.mjs — a browser stand-in for node:crypto, for the agent bundle.
-//
-// The agent uses only a small synchronous slice: SHA-256 (and HMAC-SHA-256)
-// hashing, random bytes, constant-time compare — plus WebCrypto (crypto.subtle),
-// which the browser has natively. Rather than pull in crypto-browserify (which
-// drags Node streams into the bundle), SHA-256 is implemented here in pure JS.
-// Key generation and KeyObject calls are never reached: keys are made by
-// keystore.mjs and loaded straight into WebCrypto.
-
-const K = new Uint32Array([
-  0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
-  0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
-  0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
-  0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
-  0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
-  0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
-  0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
-  0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2]);
-const rotr = (x, n) => (x >>> n) | (x << (32 - n));
-
-function sha256(bytes) {
-  const l = bytes.length;
-  const withOne = l + 1;
-  const k = (56 - (withOne % 64) + 64) % 64;
-  const total = withOne + k + 8;
-  const m = new Uint8Array(total);
-  m.set(bytes); m[l] = 0x80;
-  const bits = l * 8;
-  const dv = new DataView(m.buffer);
-  dv.setUint32(total - 4, bits >>> 0);
-  dv.setUint32(total - 8, Math.floor(bits / 0x100000000));
-  const H = new Uint32Array([0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19]);
-  const w = new Uint32Array(64);
-  for (let i = 0; i < total; i += 64) {
-    for (let t = 0; t < 16; t++) w[t] = dv.getUint32(i + t * 4);
-    for (let t = 16; t < 64; t++) {
-      const s0 = rotr(w[t-15],7) ^ rotr(w[t-15],18) ^ (w[t-15] >>> 3);
-      const s1 = rotr(w[t-2],17) ^ rotr(w[t-2],19) ^ (w[t-2] >>> 10);
-      w[t] = (w[t-16] + s0 + w[t-7] + s1) >>> 0;
-    }
-    let [a,b,c,d,e,f,g,h] = H;
-    for (let t = 0; t < 64; t++) {
-      const S1 = rotr(e,6) ^ rotr(e,11) ^ rotr(e,25);
-      const ch = (e & f) ^ (~e & g);
-      const t1 = (h + S1 + ch + K[t] + w[t]) >>> 0;
-      const S0 = rotr(a,2) ^ rotr(a,13) ^ rotr(a,22);
-      const maj = (a & b) ^ (a & c) ^ (b & c);
-      const t2 = (S0 + maj) >>> 0;
-      h=g; g=f; f=e; e=(d+t1)>>>0; d=c; c=b; b=a; a=(t1+t2)>>>0;
-    }
-    H[0]=(H[0]+a)>>>0; H[1]=(H[1]+b)>>>0; H[2]=(H[2]+c)>>>0; H[3]=(H[3]+d)>>>0;
-    H[4]=(H[4]+e)>>>0; H[5]=(H[5]+f)>>>0; H[6]=(H[6]+g)>>>0; H[7]=(H[7]+h)>>>0;
-  }
-  const out = new Uint8Array(32);
-  new DataView(out.buffer).setUint32(0, H[0]); new DataView(out.buffer).setUint32(4, H[1]);
-  new DataView(out.buffer).setUint32(8, H[2]); new DataView(out.buffer).setUint32(12, H[3]);
-  new DataView(out.buffer).setUint32(16, H[4]); new DataView(out.buffer).setUint32(20, H[5]);
-  new DataView(out.buffer).setUint32(24, H[6]); new DataView(out.buffer).setUint32(28, H[7]);
-  return out;
-}
-function hmacSha256(key, msg) {
-  if (key.length > 64) key = sha256(key);
-  const pad = new Uint8Array(64); pad.set(key);
-  const ipad = new Uint8Array(64); const opad = new Uint8Array(64);
-  for (let i = 0; i < 64; i++) { ipad[i] = pad[i] ^ 0x36; opad[i] = pad[i] ^ 0x5c; }
-  const inner = sha256(concat(ipad, msg));
-  return sha256(concat(opad, inner));
-}
-const concat = (a, b) => { const o = new Uint8Array(a.length + b.length); o.set(a); o.set(b, a.length); return o; };
-const toBytes = (data, enc) => {
-  if (data == null) return new Uint8Array(0);
-  if (typeof data === 'string') {
-    if (enc === 'hex') return Uint8Array.from(data.match(/.{1,2}/g) || [], (h) => parseInt(h, 16));
-    if (enc === 'base64') return Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
-    return new TextEncoder().encode(data);
-  }
-  return data instanceof Uint8Array ? data : new Uint8Array(data);
-};
-const encode = (bytes, enc) => {
-  if (!enc || enc === 'buffer') return bytes;
-  if (enc === 'hex') return [...bytes].map((b) => b.toString(16).padStart(2, '0')).join('');
-  const b64 = btoa(String.fromCharCode(...bytes));
-  if (enc === 'base64url') return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-  return b64;   // base64
-};
-
-export function createHash(alg) {
-  if (alg !== 'sha256') throw new Error(`node-crypto shim: only sha256 is implemented (got ${alg})`);
-  let acc = new Uint8Array(0);
-  return { update(d, e) { acc = concat(acc, toBytes(d, e)); return this; }, digest(enc) { return encode(sha256(acc), enc); } };
-}
-export function createHmac(alg, key) {
-  if (alg !== 'sha256') throw new Error(`node-crypto shim: only hmac-sha256 is implemented (got ${alg})`);
-  const k = toBytes(key); let acc = new Uint8Array(0);
-  return { update(d, e) { acc = concat(acc, toBytes(d, e)); return this; }, digest(enc) { return encode(hmacSha256(k, acc), enc); } };
-}
-// A Buffer, not a bare Uint8Array, so callers' `.toString('hex')` works (the
-// prelude defines Buffer before any bundle code runs).
-export function randomBytes(n) { const b = new Uint8Array(n); crypto.getRandomValues(b); return globalThis.Buffer ? globalThis.Buffer.from(b) : b; }
-export const webcrypto = globalThis.crypto;
-export const randomUUID = () => globalThis.crypto.randomUUID();
-export function timingSafeEqual(a, b) {
-  if (a.length !== b.length) return false;
-  let out = 0; for (let i = 0; i < a.length; i++) out |= a[i] ^ b[i];
-  return out === 0;
-}
-const unavailable = (name) => () => { throw new Error(`node:crypto ${name} is not available in the browser agent`); };
-export const generateKeyPairSync = unavailable('generateKeyPairSync');
-export const createPrivateKey = unavailable('createPrivateKey');
-export const createPublicKey = unavailable('createPublicKey');
-export const scryptSync = unavailable('scryptSync');
-export default { createHash, createHmac, randomBytes, webcrypto, randomUUID, timingSafeEqual,
-  generateKeyPairSync, createPrivateKey, createPublicKey, scryptSync };

package/web/app/shims/node-fs.mjs

@@ -1,17 +0,0 @@
-// node-fs.mjs — the tiny synchronous slice of node:fs touched at import time.
-// ua.mjs and publisher.mjs read package.json for the version; everything else
-// (FileStorage, home, certs) is never constructed in the browser.
-const PKG = JSON.stringify({ version: '0.18.0', name: 'fedipod' });
-export const readFileSync = (p) => {
-  if (String(p).endsWith('package.json')) return PKG;
-  throw new Error(`node:fs readFileSync(${p}) is not available in the browser agent`);
-};
-export const existsSync = () => false;
-const nope = (name) => () => { throw new Error(`node:fs ${name} is not available in the browser agent`); };
-export const writeFileSync = nope('writeFileSync');
-export const mkdirSync = nope('mkdirSync');
-export const readdirSync = () => [];
-export const statSync = nope('statSync');
-export const unlinkSync = nope('unlinkSync');
-export const rmSync = nope('rmSync');
-export default { readFileSync, existsSync, writeFileSync, mkdirSync, readdirSync, statSync, unlinkSync, rmSync };

package/web/app/shims/node-path.mjs

@@ -1,19 +0,0 @@
-// node-path.mjs — the POSIX slice of node:path the agent uses in the browser.
-const normalize = (p) => {
-  const up = p.startsWith('/');
-  const parts = [];
-  for (const seg of p.split('/')) {
-    if (!seg || seg === '.') continue;
-    if (seg === '..') { if (parts.length && parts[parts.length - 1] !== '..') parts.pop(); else if (!up) parts.push('..'); }
-    else parts.push(seg);
-  }
-  return (up ? '/' : '') + parts.join('/') || (up ? '/' : '.');
-};
-const join = (...segs) => normalize(segs.filter((s) => s != null && s !== '').join('/'));
-const dirname = (p) => { const i = p.replace(/\/$/, '').lastIndexOf('/'); return i <= 0 ? (i === 0 ? '/' : '.') : p.slice(0, i); };
-const basename = (p, ext) => { let b = p.slice(p.lastIndexOf('/') + 1); if (ext && b.endsWith(ext)) b = b.slice(0, -ext.length); return b; };
-const extname = (p) => { const b = basename(p); const i = b.lastIndexOf('.'); return i > 0 ? b.slice(i) : ''; };
-const resolve = (...segs) => join(...segs);
-const posix = { join, dirname, basename, extname, resolve, normalize, sep: '/' };
-export { join, dirname, basename, extname, resolve, normalize, posix };
-export default { join, dirname, basename, extname, resolve, normalize, posix, sep: '/' };

package/web/app/shims/node-url.mjs

@@ -1,7 +0,0 @@
-// node-url.mjs — the node:url slice the agent uses. URL is native; the two
-// file-path converters are only ever called with data: or http URLs in the
-// browser build, so plain string surgery suffices.
-export const fileURLToPath = (u) => { const s = typeof u === 'string' ? u : u.href; return s.replace(/^file:\/\//, ''); };
-export const pathToFileURL = (p) => new URL('file://' + (p.startsWith('/') ? p : '/' + p));
-export { URL, URLSearchParams } from './_globals.mjs';
-export default { URL: globalThis.URL, URLSearchParams: globalThis.URLSearchParams, fileURLToPath, pathToFileURL };

package/web/app/shims/prelude.js

@@ -1,58 +0,0 @@
-// prelude.js — globals the bundled Node code expects, set once before it runs.
-// Injected as the bundle's banner. Kept minimal and local: Buffer is a subclass
-// of Uint8Array (not a prototype patch), so nothing else in the page is touched.
-globalThis.process ??= { env: {}, argv: [], platform: 'browser', cwd: () => '/', nextTick: (f, ...a) => queueMicrotask(() => f(...a)) };
-globalThis.Buffer ??= (() => {
-  const b64 = (u) => btoa(String.fromCharCode(...u));
-  const hex = (u) => { let s = ''; for (const b of u) s += b.toString(16).padStart(2, '0'); return s; };
-  class Buf extends Uint8Array {
-    // Uint8Array.indexOf finds a single BYTE; Node's Buffer finds a whole
-    // subsequence, and lib/mastoapi.mjs's readMultipart walks a multipart body
-    // by searching for the boundary and for the CRLFCRLF that ends each part's
-    // headers. Without this every search returned -1, so an upload came back
-    // "file required" however good the bytes were.
-    indexOf(needle, from = 0) {
-      const pat = typeof needle === 'string' ? new TextEncoder().encode(needle)
-        : needle instanceof Uint8Array ? needle : null;
-      if (pat === null) return super.indexOf(needle, from);      // a single byte
-      if (pat.length === 0) return Math.min(from, this.length);
-      const last = this.length - pat.length;
-      outer: for (let i = Math.max(0, from); i <= last; i++) {
-        for (let j = 0; j < pat.length; j++) if (this[i + j] !== pat[j]) continue outer;
-        return i;
-      }
-      return -1;
-    }
-    toString(enc) {
-      if (enc === 'hex') return hex(this);
-      if (enc === 'base64') return b64(this);
-      if (enc === 'base64url') return b64(this).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
-      return new TextDecoder().decode(this);
-    }
-  }
-  const fromString = (s, enc) => {
-    if (enc === 'hex') return Buf.from(s.match(/.{1,2}/g) || [], (h) => parseInt(h, 16));
-    if (enc === 'base64' || enc === 'base64url') {
-      const n = s.replace(/-/g, '+').replace(/_/g, '/');
-      return Buf.from(atob(n + '==='.slice((n.length + 3) % 4)), (c) => c.charCodeAt(0));
-    }
-    return Buf.from(new TextEncoder().encode(s));
-  };
-  const from = (d, enc) => {
-    if (typeof d === 'string') return fromString(d, enc);
-    if (typeof d === 'function') { const args = arguments; return Uint8Array.from.call(Buf, args[0], args[1]); }
-    const b = new Buf(d.length); b.set(d); return b;
-  };
-  const fromAny = (d, e) => {
-    if (typeof d === 'string') return fromString(d, e);
-    if (typeof e === 'function') { const arr = Array.from(d, e); const b = new Buf(arr.length); b.set(arr); return b; }
-    if (d instanceof Uint8Array || Array.isArray(d)) { const b = new Buf(d.length); b.set(d); return b; }
-    return new Buf(d);
-  };
-  return {
-    from: fromAny,
-    concat: (list) => { const n = list.reduce((s, x) => s + x.length, 0); const o = new Buf(n); let i = 0; for (const x of list) { o.set(x, i); i += x.length; } return o; },
-    alloc: (n) => new Buf(n),
-    isBuffer: (x) => x instanceof Uint8Array,
-  };
-})();