@dotrino/content 0.3.13

package/src/ops.js

@@ -0,0 +1,220 @@
+/**
+ * ops.js — las operaciones del PLANO DE CONTROL del node (DISENO.md §5.1 y §7).
+ *
+ * Es lo que tus propias apps pueden pedirle a este node a distancia: ver qué
+ * guarda, retener, soltar, borrar y marcar qué es público. Módulo PURO: no sabe de
+ * red, de sesiones ni de firmas — recibe un objeto ya descifrado y autorizado, y
+ * devuelve la respuesta. Así se prueba entero sin levantar nada, y quien autoriza
+ * (`agent.js`, vía `@dotrino/remote-agent`) queda en un solo sitio.
+ *
+ * SOBRE `put` Y `get`: existen, pero con un TOPE DURO de un mensaje (256 KB), y
+ * eso no es una limitación técnica que haya que levantar después — es la frontera
+ * (§7.1). El plano de control es el proxy del ecosistema: sus tramas son de 1 MB y
+ * su cola es de mensajes, no un almacén, y meter contenido por ahí sería usar la
+ * infraestructura de Dotrino como transporte, que es la regla dura 3. Por eso NO
+ * hay subida por partes: si algo no cabe en un mensaje, es que no es un mensaje.
+ *
+ * Lo que sí es un mensaje y por eso pasa: **un post** (un eco pesa cientos de
+ * bytes) y **una miniatura** (decenas de KB). Los originales suben en local por
+ * HTTP y, entre aparatos, por P2P — que es lo que este tope deja pendiente a
+ * propósito en vez de disimularlo con un troceado.
+ *
+ * El contrato de errores es `code`, no la frase: quien recibe compara `code`
+ * (`bad-request`, `not-found`, `unknown-op`, `failed`), que es lo estable. La frase
+ * es para un humano leyendo una bitácora.
+ */
+
+/** Valores admitidos de ACL. Público es OPT-IN explícito; lo que no se dice, privado. */
+export const ACL = Object.freeze({ PUBLIC: 'public', PRIVATE: 'private' })
+
+/**
+ * Tope de lo que puede entrar o salir por el plano de control, en bytes crudos.
+ * En base64 dentro del sobre cifrado son ~350 KB, cómodos bajo la trama de 1 MB
+ * del proxy. **Es una frontera de diseño, no un parámetro a subir**: lo que no
+ * cabe aquí no es un mensaje y va por el otro camino.
+ */
+export const CONTROL_PLANE_MAX_BYTES = 256 * 1024
+
+import { Readable } from 'node:stream'
+import { isValidCid } from './blobstore.js'
+
+const ok = (rid, result) => ({ rid, ok: true, ...result })
+const fail = (rid, code, error) => ({ rid, ok: false, code, error })
+
+/**
+ * Metadatos de presentación, quedándose SOLO con los campos conocidos y
+ * recortados. Esto acaba en un HTML público (§7.3), así que no se guarda lo que
+ * llegue: ni campos de más ni textos sin fin.
+ * @returns {{name?:string,title?:string,description?:string}|null}
+ */
+/** Cuántos enlaces lleva una tarjeta, y cuánto puede medir cada uno. */
+const MAX_LINKS = 4
+const MAX_LINK_LEN = 300
+
+function cleanMeta (src) {
+  if (!src || typeof src !== 'object') return null
+  const out = Object.fromEntries(['name', 'title', 'description']
+    .map((k) => [k, typeof src[k] === 'string' ? src[k].trim().slice(0, 300) : null])
+    .filter(([, v]) => v))
+  // Los ENLACES del contenido (en un eco, la fuente de la que habla). Solo http(s)
+  // y contados: `meta` lo escribe quien publica y la tarjeta lo pinta como `href`,
+  // así que aquí se filtra en vez de creerse.
+  const links = (Array.isArray(src.links) ? src.links : [])
+    .filter((u) => typeof u === 'string')
+    .map((u) => u.trim())
+    .filter((u) => /^https?:\/\//i.test(u) && u.length <= MAX_LINK_LEN)
+    .slice(0, MAX_LINKS)
+  if (links.length) out.links = links
+  return Object.keys(out).length ? out : null
+}
+
+/**
+ * Construye el despachador de operaciones de un node.
+ *
+ * @param {import('./node.js').ContentNode} node
+ * @param {{ owner?: string|null, version?: string }} [meta]
+ *   owner: `ownerId` (huella de la maestra) que este node representa — es la mitad
+ *   de la referencia compartible `ownerId + cid` (§3).
+ * @returns {(msg: any) => Promise<any>}
+ */
+export function createOps (node, { owner = null, version = null } = {}) {
+  /** Operaciones que exigen un `cid` válido y que el blob exista. */
+  const withBlob = (fn) => async (msg) => {
+    const cid = typeof msg.cid === 'string' ? msg.cid : null
+    if (!cid) return fail(msg.rid, 'bad-request', 'cid is required')
+    const meta = node.stat(cid)
+    if (!meta) return fail(msg.rid, 'not-found', 'no such cid')
+    return fn(msg, cid, meta)
+  }
+
+  const handlers = {
+    /** Quién es este node: sirve de saludo y de comprobación de vida. */
+    hello: async (msg) => ok(msg.rid, {
+      owner, version, stats: node.stats(), maxBytes: CONTROL_PLANE_MAX_BYTES
+    }),
+
+    /**
+     * Guardar algo pequeño desde otro aparato tuyo. Los bytes llegan en base64
+     * dentro del sobre ya cifrado de la sesión, en UN mensaje: no hay subida por
+     * partes y no la va a haber (ver la cabecera del archivo).
+     *
+     * Que el aparato esté autorizado ya lo comprobó `verifyChain` antes de que
+     * esto se llame; aquí solo se comprueba la forma y el tamaño.
+     */
+    put: async (msg) => {
+      if (typeof msg.data !== 'string') return fail(msg.rid, 'bad-request', 'data (base64) is required')
+      let buf
+      try { buf = Buffer.from(msg.data, 'base64') } catch { return fail(msg.rid, 'bad-request', 'data is not valid base64') }
+      if (!buf.length) return fail(msg.rid, 'bad-request', 'empty payload')
+      if (buf.length > CONTROL_PLANE_MAX_BYTES) {
+        return fail(msg.rid, 'too-large',
+          `the control plane carries up to ${CONTROL_PLANE_MAX_BYTES} bytes; upload larger blobs locally or peer to peer`)
+      }
+      const enc = msg.enc ? 1 : 0
+      // Mismo cerrojo que en `acl`, y por lo mismo: decir que algo cifrado es
+      // público solo engaña a quien lo mire, porque nadie sin la llave lo lee.
+      const acl = msg.acl === ACL.PUBLIC && !enc ? ACL.PUBLIC : ACL.PRIVATE
+      const ttlMs = Number(msg.ttl) || 0
+      const out = await node.put(Readable.from(buf), {
+        mime: typeof msg.mime === 'string' ? msg.mime : 'application/octet-stream',
+        enc,
+        acl,
+        ttl: ttlMs > 0 ? Date.now() + ttlMs : null,
+        meta: cleanMeta(msg.meta)
+      })
+      return ok(msg.rid, { ...out, acl })
+    },
+
+    /**
+     * Leer algo pequeño de vuelta (otro aparato tuyo, o el mismo tras reinstalar).
+     * Mismo tope, y por la misma razón: esto es el plano de control.
+     */
+    get: withBlob(async (msg, cid, meta) => {
+      if (meta.size > CONTROL_PLANE_MAX_BYTES) {
+        return fail(msg.rid, 'too-large',
+          `${meta.size} bytes do not fit in the control plane; fetch it locally or peer to peer`)
+      }
+      const chunks = []
+      for await (const c of node.read(cid)) chunks.push(c)
+      return ok(msg.rid, {
+        cid, size: meta.size, mime: meta.mime, enc: meta.enc, data: Buffer.concat(chunks).toString('base64')
+      })
+    }),
+
+    list: async (msg) => ok(msg.rid, { blobs: node.list() }),
+
+    stats: async (msg) => ok(msg.rid, { stats: node.stats() }),
+
+    stat: withBlob(async (msg, cid, meta) => ok(msg.rid, { blob: meta })),
+
+    /** Retener: un blob pineado no lo borra el GC ni por cuota ni por ttl. */
+    pin: withBlob(async (msg, cid) => ok(msg.rid, { pinned: node.pin(cid, true) })),
+
+    unpin: withBlob(async (msg, cid) => ok(msg.rid, { pinned: !node.pin(cid, false) })),
+
+    remove: withBlob(async (msg, cid) => {
+      await node.remove(cid)
+      return ok(msg.rid, { removed: cid })
+    }),
+
+    /**
+     * Marcar un blob como público o privado. Es el interruptor que la Fase 3 mira
+     * antes de servir algo por HTTP: sin `public` explícito, no sale del node.
+     */
+    acl: withBlob(async (msg, cid) => {
+      const acl = msg.acl === ACL.PUBLIC ? ACL.PUBLIC : msg.acl === ACL.PRIVATE ? ACL.PRIVATE : null
+      if (!acl) return fail(msg.rid, 'bad-request', `acl must be "${ACL.PUBLIC}" or "${ACL.PRIVATE}"`)
+      const meta = node.stat(cid)
+      // Un blob cifrado no se puede marcar público: nadie sin la llave podría leerlo,
+      // así que decir que lo es solo engaña a quien lo mire.
+      if (acl === ACL.PUBLIC && meta.enc) return fail(msg.rid, 'bad-request', 'an encrypted blob cannot be public')
+      node.setAcl(cid, acl)
+      return ok(msg.rid, { cid, acl })
+    }),
+
+    /**
+     * Metadatos de PRESENTACIÓN (nombre, título, descripción). Es lo único con lo
+     * que la vista previa pública arma su tarjeta (§7.3): sin esto, una tarjeta
+     * solo puede decir el tipo y el tamaño. No forma parte del `cid` —dos nombres
+     * para los mismos bytes son el mismo blob—, por eso se pone aparte.
+     */
+    meta: withBlob(async (msg, cid) => {
+      if (msg.meta !== null && (!msg.meta || typeof msg.meta !== 'object')) {
+        return fail(msg.rid, 'bad-request', 'meta must be an object or null')
+      }
+      const clean = cleanMeta(msg.meta)
+      node.setMeta(cid, clean)
+      return ok(msg.rid, { cid, meta: clean })
+    }),
+
+    /**
+     * Enlaza la miniatura de un blob. La miniatura es OTRO blob (subido por la
+     * app) y tiene que ser pública por su cuenta: enlazarla no la publica.
+     */
+    thumb: withBlob(async (msg, cid) => {
+      const t = msg.thumbnailCid
+      if (t !== null && !isValidCid(t)) return fail(msg.rid, 'bad-request', 'thumbnailCid must be a valid cid or null')
+      if (t && !node.stat(t)) return fail(msg.rid, 'not-found', 'the thumbnail is not in this node')
+      node.setThumbnail(cid, t)
+      return ok(msg.rid, { cid, thumbnailCid: t })
+    }),
+
+    /** Recolección de vencidos (lo que el temporizador hace solo, a pedido). */
+    gc: async (msg) => ok(msg.rid, node.gc())
+  }
+
+  return async function dispatch (msg) {
+    if (!msg || typeof msg !== 'object' || typeof msg.op !== 'string') {
+      return fail(msg?.rid, 'bad-request', 'op is required')
+    }
+    const handler = handlers[msg.op]
+    if (!handler) return fail(msg.rid, 'unknown-op', `unknown op: ${msg.op}`)
+    try {
+      return await handler(msg)
+    } catch (e) {
+      return fail(msg.rid, e?.code === 'ENOSPC' ? 'no-space' : 'failed', e?.message || 'failed')
+    }
+  }
+}
+
+export default { createOps, ACL, CONTROL_PLANE_MAX_BYTES }

package/src/public.js

@@ -0,0 +1,400 @@
+/**
+ * public.js — MODO PÚBLICO del node (DISENO.md §7.2 y §7.3). APAGADO por defecto.
+ *
+ * Es la única puerta por la que los bytes de este node salen a internet sin pasar
+ * por una app del ecosistema, y existe para UNA cosa: que un enlace compartido
+ * tenga **vista previa** (la tarjeta de X, LinkedIn, WhatsApp, Telegram…). El
+ * contenido de verdad sigue viajando por el camino de siempre — app + `#fragment`
+ * + transporte P2P—, donde el servidor nunca ve la referencia.
+ *
+ * Cuatro cerrojos, y ninguno es decorativo:
+ *
+ *  1. **ACL:** solo sale lo marcado `public` y EN CLARO. Lo cifrado no sale ni
+ *     aunque alguien le ponga `public` a mano en el índice (`node.publicStat`).
+ *  1b. **SOLO IMÁGENES, y de mapa de bits.** Es lo único que una vista previa
+ *     necesita, y de paso cierra de golpe todo lo demás: nada de HTML, PDF,
+ *     vídeo ni archivos comprimidos saliendo de tu máquina. **El SVG queda
+ *     fuera a propósito**: es un documento que ejecuta scripts, así que servirlo
+ *     desde tu dominio es regalarle un origen a quien lo suba. Y el tipo NO se
+ *     cree: el `mime` lo declara quien sube, así que se comprueban los BYTES
+ *     MÁGICOS del archivo antes de mandarlo (`sniffImage`).
+ *  2. **TOPE DE TAMAÑO (`maxBytes`, 512 KB por defecto):** es lo que convierte
+ *     esto en «un servidor de miniaturas» en vez de «un CDN gratis». Una
+ *     miniatura pesa decenas de KB; un original, megas. Con el tope puesto, el
+ *     hotlinking —que es el modo natural en que esta puerta te cuesta dinero—
+ *     deja de importar. `maxBytes: 0` lo quita, y es una decisión del dueño.
+ *  3. **Límite por IP:** cubeta por minuto, para que un bucle ajeno no te use de
+ *     origen.
+ *  4. **TECHO DE EGRESS DIARIO, persistido:** al pasarse, corta con 503. Se
+ *     guarda en el índice y no en memoria a propósito: un techo que se reinicia
+ *     con el proceso no es un techo.
+ *
+ * Rutas (y no hay más):
+ *   GET|HEAD /c/<cid>   los bytes, si pasan los cuatro cerrojos (Range/206, ETag)
+ *   GET      /p/<cid>   permalink: HTML con las etiquetas OG de la tarjeta
+ *   GET      /robots.txt  Disallow: / (ver abajo)
+ *   GET      /health    vivo + uso del techo, sin decir qué guarda
+ *
+ * `robots.txt` prohíbe TODO a propósito. Las tarjetas sociales funcionan igual
+ * (los rastreadores de redes piden la página cuando alguien pega el enlace, no
+ * indexan), y la norma del ecosistema es que el contenido del usuario no se
+ * indexa (CLAUDE.md §SEO). Se puede levantar con `index: true`, que es lo que
+ * haría la cuenta oficial para su contenido público, y de nadie más.
+ */
+import http from 'node:http'
+import { open as openFile } from 'node:fs/promises'
+import { pipeline } from 'node:stream/promises'
+import { isValidCid } from './node.js'
+
+export const DEFAULT_PUBLIC_PORT = 3778
+/** Tope por blob: lo que hace que esto sirva previsualizaciones y no originales. */
+export const DEFAULT_MAX_BYTES = 512 * 1024
+/** Cubeta por IP y minuto. */
+export const DEFAULT_RATE_PER_MIN = 60
+
+/**
+ * Lo único que sale por el puerto público: imágenes de mapa de bits. Cada entrada
+ * lleva su firma en los primeros bytes, porque el `mime` del índice es lo que
+ * DIJO quien subió, y aquí no se cree nada que no se pueda comprobar.
+ */
+const IMAGE_TYPES = [
+  { mime: 'image/jpeg', test: (b) => b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff },
+  { mime: 'image/png', test: (b) => b[0] === 0x89 && b[1] === 0x50 && b[2] === 0x4e && b[3] === 0x47 },
+  { mime: 'image/gif', test: (b) => b[0] === 0x47 && b[1] === 0x49 && b[2] === 0x46 && b[3] === 0x38 },
+  // RIFF....WEBP
+  { mime: 'image/webp', test: (b) => b.subarray(0, 4).toString('latin1') === 'RIFF' && b.subarray(8, 12).toString('latin1') === 'WEBP' },
+  // ....ftypavif  (caja ISO-BMFF)
+  { mime: 'image/avif', test: (b) => b.subarray(4, 8).toString('latin1') === 'ftyp' && b.subarray(8, 12).toString('latin1').startsWith('avif') }
+]
+
+export const PUBLIC_MIMES = Object.freeze(IMAGE_TYPES.map((t) => t.mime))
+
+/**
+ * El tipo REAL a partir de los primeros bytes, o `null` si no es una imagen de las
+ * admitidas. Es lo que se sirve como `content-type`: si alguien subió un HTML diciendo
+ * que era un PNG, aquí no pasa.
+ * @param {Buffer|Uint8Array|null} buf
+ * @returns {string|null}
+ */
+export function sniffBytes (buf) {
+  if (!buf || buf.length < 12) return null
+  return IMAGE_TYPES.find((t) => t.test(buf))?.mime || null
+}
+
+/**
+ * El tipo real de un blob, pidiéndole al ALMACÉN sus primeros bytes.
+ *
+ * Antes abría el archivo por su ruta (`node.store.pathFor`), y eso ataba este cerrojo
+ * al disco: con un bucket detrás (§15) no hay ninguna ruta que abrir y el puerto
+ * público se habría quedado sin poder comprobar nada — o, peor, comprobándolo solo
+ * cuando el blob estuviera en la caché.
+ * @param {{ readHead: (cid: string, n: number, opts?: any) => Promise<Buffer|Uint8Array> }} store
+ * @param {string} cid
+ * @param {any} [opts]
+ * @returns {Promise<string|null>}
+ */
+export async function sniffImage (store, cid, opts) {
+  try {
+    return sniffBytes(await store.readHead(cid, 16, opts))
+  } catch {
+    return null
+  }
+}
+
+/** Día UTC (clave del techo de egress). */
+export const utcDay = (now = Date.now()) => new Date(now).toISOString().slice(0, 10)
+
+const esc = (s) => String(s ?? '')
+  .replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+  .replace(/"/g, '&quot;').replace(/'/g, '&#39;')
+
+const text = (res, code, body, extra = {}) =>
+  res.writeHead(code, { 'content-type': 'text/plain; charset=utf-8', ...extra }).end(body)
+
+const json = (res, code, obj) =>
+  res.writeHead(code, { 'content-type': 'application/json' }).end(JSON.stringify(obj))
+
+/** Cubeta por IP: N peticiones por minuto, ventana deslizante gruesa (por minuto). */
+export class RateLimiter {
+  constructor (perMinute = DEFAULT_RATE_PER_MIN) {
+    this.perMinute = perMinute
+    this.window = 0
+    this.hits = new Map()
+  }
+
+  /** @returns {boolean} true si la petición pasa. */
+  allow (ip, now = Date.now()) {
+    if (!this.perMinute) return true
+    const w = Math.floor(now / 60_000)
+    if (w !== this.window) { this.window = w; this.hits.clear() }
+    const n = (this.hits.get(ip) || 0) + 1
+    this.hits.set(ip, n)
+    return n <= this.perMinute
+  }
+}
+
+/** IP del cliente, respetando un proxy inverso delante (nginx/Caddy/Cloudflare). */
+export function clientIp (req) {
+  const fwd = req.headers['x-forwarded-for']
+  if (typeof fwd === 'string' && fwd) return fwd.split(',')[0].trim()
+  return req.socket?.remoteAddress || '?'
+}
+
+/** Base pública absoluta (para las URLs de las etiquetas OG). */
+function baseUrl (req, configured) {
+  if (configured) return configured.replace(/\/+$/, '')
+  const proto = (req.headers['x-forwarded-proto'] || 'http').toString().split(',')[0].trim()
+  const host = req.headers.host || 'localhost'
+  return `${proto}://${host}`
+}
+
+/** El host de una URL, o '' si no se puede leer. */
+const hostOf = (u) => { try { return new URL(u).hostname } catch { return '' } }
+
+/** Un enlace legible: se cae el `https://` y la cola larga, no el destino. */
+function shortLink (u) {
+  try {
+    const url = new URL(u)
+    const tail = (url.pathname === '/' ? '' : url.pathname) + url.search
+    return url.hostname.replace(/^www\./, '') + (tail.length > 40 ? tail.slice(0, 39) + '…' : tail)
+  } catch { return u }
+}
+
+const parseMeta = (row) => {
+  if (!row?.meta) return {}
+  try { return JSON.parse(row.meta) || {} } catch { return {} }
+}
+
+/**
+ * Página del permalink (§7.3). Es una tarjeta y un enlace, y se dice así: no
+ * pretende ser un visor. Lleva la imagen solo si el propio blob es una imagen o
+ * si tiene una miniatura pública enlazada (`thumbnailCid`).
+ *
+ * El texto se pinta ENTERO: recortarlo aquí dejaba tarjetas cortadas a mitad de
+ * frase, y quien decide cuánto texto hay es quien lo publicó, no esta página.
+ * Si el contenido trae enlaces (`meta.links` — en un eco, la fuente de la que
+ * habla), se pintan: sin ellos la tarjeta cuenta la noticia y esconde de dónde
+ * salió.
+ */
+export function previewHtml ({ cid, row, base, appUrl, owner, index, imageCid = null, imageFallback = null }) {
+  const m = parseMeta(row)
+  const title = m.title || m.name || 'Contenido compartido'
+  // La imagen de la tarjeta la decide la ruta, que es quien pudo COMPROBAR que
+  // ese cid es una imagen de verdad y que sale por el puerto. Aquí solo se pinta.
+  // Sin imagen propia, la tarjeta de la app (`og.jpg`): una tarjeta sin imagen casi no
+  // se ve en X/LinkedIn, y la app es de quien es el contenido.
+  const image = imageCid ? `${base}/c/${imageCid}` : (imageFallback || null)
+  const kb = Math.max(1, Math.round(row.size / 1024))
+  const desc = m.description || `${row.mime} · ${kb} KB`
+  // El enlace de "abrir" lleva la referencia en el #fragment: el servidor de la
+  // app nunca la ve (CLAUDE.md §SEO). Sin `owner` no hay referencia que armar.
+  const open = owner ? `${appUrl.replace(/\/+$/, '')}/#${owner}/${cid}` : null
+  // Solo http(s): `meta` lo escribe quien publica, y un `javascript:` en un href
+  // sería un agujero abierto de par en par.
+  const links = (Array.isArray(m.links) ? m.links : [])
+    .map((u) => String(u)).filter((u) => /^https?:\/\//i.test(u)).slice(0, 4)
+  const openLabel = `Abrir en ${hostOf(appUrl) || 'la app'}`
+  return `<!doctype html>
+<html lang="es">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>${esc(title)}</title>
+<meta name="robots" content="${index ? 'index, follow' : 'noindex, nofollow'}">
+<meta name="description" content="${esc(desc)}">
+<link rel="canonical" href="${esc(base)}/p/${cid}">
+<meta property="og:type" content="website">
+<meta property="og:site_name" content="Dotrino">
+<meta property="og:title" content="${esc(title)}">
+<meta property="og:description" content="${esc(desc)}">
+<meta property="og:url" content="${esc(base)}/p/${cid}">
+${image ? `<meta property="og:image" content="${esc(image)}">` : ''}
+<meta name="twitter:card" content="${image ? 'summary_large_image' : 'summary'}">
+<meta name="twitter:title" content="${esc(title)}">
+<meta name="twitter:description" content="${esc(desc)}">
+${image ? `<meta name="twitter:image" content="${esc(image)}">` : ''}
+<style>
+  :root { color-scheme: dark; }
+  body { margin: 0; min-height: 100vh; display: grid; place-items: center;
+         background: #0e1116; color: #e8ecf1; font: 16px/1.5 system-ui, sans-serif;
+         padding: max(1rem, env(safe-area-inset-top)) 1rem; }
+  main { max-width: 34rem; text-align: center; }
+  img { max-width: 100%; height: auto; border-radius: .75rem; }
+  h1 { font-size: 1.25rem; margin: 1rem 0 .25rem; }
+  p { color: #9aa7b4; margin: .25rem 0 1.25rem; text-align: left; }
+  ul.links { list-style: none; margin: 0 0 1.25rem; padding: 0; text-align: left;
+             overflow-wrap: anywhere; }
+  ul.links li { margin: .2rem 0; }
+  a { color: #6ea0ff; }
+  a.open { font-weight: 600; }
+  small { display: block; margin-top: 1.5rem; color: #6b7787; }
+  small a { color: #6b7787; }
+</style>
+</head>
+<body>
+<main>
+${image ? `<img src="${esc(image)}" alt="${esc(title)}">` : ''}
+<h1>${esc(title)}</h1>
+<p>${esc(desc)}</p>
+${links.length ? `<ul class="links">${links.map((u) => `<li><a href="${esc(u)}" rel="noopener nofollow">${esc(shortLink(u))}</a></li>`).join('')}</ul>` : ''}
+${open ? `<a class="open" href="${esc(open)}">${esc(openLabel)}</a>` : ''}
+<small>Servido desde el node de su dueño · <a href="https://content.dotrino.com/">Dotrino</a></small>
+</main>
+</body>
+</html>`
+}
+
+/**
+ * Servidor del modo público.
+ *
+ * @param {import('./node.js').ContentNode} node
+ * @param {{
+ *   maxBytes?: number, ratePerMin?: number, maxEgressBytes?: number,
+ *   publicUrl?: string|null, appUrl?: string, index?: boolean, owner?: string|null,
+ *   quiet?: boolean
+ * }} [opts]
+ */
+export function createPublicServer (node, opts = {}) {
+  const maxBytes = opts.maxBytes ?? DEFAULT_MAX_BYTES
+  const maxEgressBytes = opts.maxEgressBytes || 0
+  const appUrl = opts.appUrl || 'https://eco.dotrino.com/'
+  const limiter = new RateLimiter(opts.ratePerMin ?? DEFAULT_RATE_PER_MIN)
+
+  /** ¿Queda techo de egress para hoy? */
+  const egressLeft = () => {
+    if (!maxEgressBytes) return Infinity
+    return maxEgressBytes - node.index.egressOn(utcDay())
+  }
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      if (!limiter.allow(clientIp(req))) return text(res, 429, 'demasiadas peticiones\n', { 'retry-after': '60' })
+      await route(req, res)
+    } catch (err) {
+      if (res.headersSent) { res.destroy(); return }
+      text(res, 500, 'error\n')
+      if (!opts.quiet) console.error('[content:public]', err.message)
+    }
+  })
+
+  async function route (req, res) {
+    if (req.method !== 'GET' && req.method !== 'HEAD') return text(res, 405, 'método no permitido\n')
+    const url = new URL(req.url, 'http://localhost')
+    const [, top, cid] = url.pathname.split('/')
+
+    if (url.pathname === '/robots.txt') {
+      return text(res, 200, opts.index ? 'User-agent: *\nAllow: /p/\nDisallow: /c/\n' : 'User-agent: *\nDisallow: /\n')
+    }
+    if (url.pathname === '/health') {
+      const used = maxEgressBytes ? node.index.egressOn(utcDay()) : 0
+      return json(res, 200, { ok: true, egressToday: used, maxEgressBytes: maxEgressBytes || null })
+    }
+
+    if ((top === 'c' || top === 'p') && cid) {
+      if (!isValidCid(cid)) return text(res, 400, 'cid inválido\n')
+      // 404 y no 403 para lo privado: un 403 confirmaría que ese cid existe aquí.
+      const row = node.publicStat(cid)
+      if (!row) return text(res, 404, 'no disponible\n')
+
+      if (top === 'p') {
+        const body = previewHtml({
+          cid, row, imageCid: await pickImage(cid, row),
+          base: baseUrl(req, opts.publicUrl), appUrl, owner: opts.owner ?? node.owner, index: !!opts.index,
+          imageFallback: opts.imageFallback ?? `${appUrl.replace(/\/+$/, '')}/og.jpg`
+        })
+        res.writeHead(200, {
+          'content-type': 'text/html; charset=utf-8',
+          'cache-control': 'public, max-age=3600',
+          'x-robots-tag': opts.index ? 'all' : 'noindex, nofollow'
+        })
+        return res.end(req.method === 'HEAD' ? undefined : body)
+      }
+
+      // --- bytes ---
+      // El tipo REAL, sacado del archivo. `row.mime` no decide nada aquí.
+      const kind = await sniffImage(node.store, cid, { public: true })
+      if (!kind) return text(res, 404, 'no disponible\n')
+      if (maxBytes && row.size > maxBytes) {
+        // No es un error del que pide: es la política del node. Se dice cuál es.
+        return text(res, 413, 'este node solo publica vistas previas; el contenido se abre en la app\n')
+      }
+      const headers = {
+        'content-type': kind,
+        etag: `"${cid}"`,
+        'cache-control': 'public, max-age=31536000, immutable',
+        'accept-ranges': 'bytes',
+        'x-content-type-options': 'nosniff',
+        'x-robots-tag': 'noindex',
+        // El blob es de otro dominio y lo pide una app del ecosistema: sin CORS
+        // el <img>/fetch de la app no lo puede leer.
+        'access-control-allow-origin': '*'
+      }
+      if (req.headers['if-none-match'] === `"${cid}"`) return res.writeHead(304, headers).end()
+
+      const range = parseRangeHeader(req.headers.range, row.size)
+      if (range === false) return res.writeHead(416, { 'content-range': `bytes */${row.size}` }).end()
+      const sending = range ? range.end - range.start + 1 : row.size
+      // El techo se mira contra lo que ESTA respuesta va a mandar, no contra cero:
+      // dejar entrar una petición porque "aún quedan 10 bytes" es rebasarlo igual,
+      // solo que fingiendo que no. Un HEAD no manda cuerpo, así que no gasta.
+      if (req.method === 'GET' && egressLeft() < sending) {
+        return text(res, 503, 'techo de salida diario alcanzado\n', { 'retry-after': '3600' })
+      }
+      if (range) {
+        headers['content-range'] = `bytes ${range.start}-${range.end}/${row.size}`
+        headers['content-length'] = sending
+        res.writeHead(206, headers)
+      } else {
+        headers['content-length'] = sending
+        res.writeHead(200, headers)
+      }
+      if (req.method === 'HEAD') return res.end()
+      // Se contabiliza lo que de verdad sale por el socket, no lo que se prometió:
+      // una descarga abortada a la mitad no debe gastar el techo entero.
+      let sent = 0
+      res.on('close', () => { if (maxEgressBytes && sent) node.index.addEgress(sent, utcDay()) })
+      const src = node.read(cid, range ?? undefined)
+      src.on('data', (c) => { sent += c.length })
+      await pipeline(src, res)
+      return
+    }
+
+    return text(res, 404, 'no disponible\n')
+  }
+
+  /**
+   * Qué imagen lleva la tarjeta: el propio blob si es una imagen servible, y si
+   * no su miniatura (`thumbnailCid`), que tiene que ser pública por su cuenta —
+   * enlazar una miniatura no la vuelve pública, la publica su dueño.
+   * @returns {Promise<string|null>}
+   */
+  async function pickImage (cid, row) {
+    for (const candidate of [{ cid, row }, row.thumbnailCid ? { cid: row.thumbnailCid, row: node.publicStat(row.thumbnailCid) } : null]) {
+      if (!candidate?.row) continue
+      if (maxBytes && candidate.row.size > maxBytes) continue
+      if (await sniffImage(node.store, candidate.cid, { public: true })) return candidate.cid
+    }
+    return null
+  }
+
+  return server
+}
+
+/** Igual que el del servidor local; duplicado mínimo para no acoplar los dos. */
+function parseRangeHeader (header, size) {
+  if (!header) return null
+  const m = /^bytes=(\d*)-(\d*)$/.exec(String(header).trim())
+  if (!m || (m[1] === '' && m[2] === '')) return false
+  let start, end
+  if (m[1] === '') {
+    const n = Number(m[2])
+    if (n === 0) return false
+    start = Math.max(0, size - n); end = size - 1
+  } else {
+    start = Number(m[1]); end = m[2] === '' ? size - 1 : Math.min(Number(m[2]), size - 1)
+  }
+  if (start >= size || start > end) return false
+  return { start, end }
+}
+
+export default { createPublicServer, RateLimiter, previewHtml, utcDay, DEFAULT_PUBLIC_PORT, DEFAULT_MAX_BYTES }