@dotrino/content 0.3.13

package/src/agent.js

@@ -0,0 +1,111 @@
+/**
+ * agent.js — Fase 2 (DISENO.md §5, §11): este node deja de ser una pieza local y
+ * pasa a ser un APARATO DEL VAULT, administrable a distancia desde tus propias apps
+ * sin abrir un solo puerto.
+ *
+ * NO IMPLEMENTA NADA DE ESO: lo hace `@dotrino/remote-agent`, el middleware que ya
+ * usan `dotrino-terminal` y `dotrino-ia`. De ahí salen, y por eso no se reescriben
+ * aquí: el enrolamiento contra el vault (llave `D` propia + cert `D ← maestra`, la
+ * maestra nunca vive aquí), el `identify` firmado en el proxy, el canal cifrado por
+ * sesión, el refresco de la lista de revocados, la RENOVACIÓN del cert antes de que
+ * venza y el auto-borrado cuando llega un `vault.revoked` firmado por la maestra.
+ *
+ * Lo único de este archivo es el pegamento: cada payload que llega por una sesión
+ * ya autorizada se despacha en `ops.js`, y la respuesta vuelve por el mismo canal
+ * cifrado. Autorizar = tener un cert de LA MISMA maestra que este node (eso lo
+ * comprueba `verifyChain` dentro del middleware); no hay lista de invitados propia.
+ *
+ * El `owner` del node se deriva de la maestra a la que está enlazado: es el
+ * `ownerId` de la referencia compartible `ownerId + cid` (§3), y se estampa en todo
+ * lo que se suba mientras el node esté enlazado.
+ */
+import { pubkeyId } from '@dotrino/identity/capabilities'
+import { startRemoteAgent } from '@dotrino/remote-agent/agent'
+import { dataDir, loadLink } from '@dotrino/remote-agent/link'
+import { startAnnounce } from './announce.js'
+import { startPublicFetch } from './fetch.js'
+import { createOps } from './ops.js'
+
+/** Carpeta de datos del enlace (NO es la de los blobs: el enlace es del aparato). */
+export const linkDir = () => process.env.DOTRINO_CONTENT_LINK_DIR || dataDir('dotrino-content')
+
+/** ¿Está este node enlazado a un vault? (sin enlace, Fase 1: solo loopback) */
+export const isLinked = (dir = linkDir()) => {
+  const link = loadLink(dir)
+  return !!(link?.device?.privateJwk && link?.cert && link?.iss)
+}
+
+/**
+ * Arranca el plano de control del node.
+ *
+ * @param {{
+ *   node?: import('./node.js').ContentNode,
+ *   dir?: string, proxyUrl?: string, version?: string|null,
+ *   client?: any, quiet?: boolean, onRevoked?: () => void, announce?: boolean
+ * }} opts
+ *   client: transporte inyectado — SOLO para pruebas (bus en memoria). En
+ *   producción lo levanta el middleware con el proxy del ecosistema.
+ *   announce: publicarse en el canal del dueño para que un TERCERO con el enlace
+ *   pueda encontrar este node (§3.1). Encendido por defecto; se apaga con `false`
+ *   en un node que solo quieras usar desde tus propios aparatos.
+ * @returns {Promise<{ machine: string, machineId: string, owner: string, close: () => void }>}
+ */
+export async function startContentAgent ({
+  node, dir = linkDir(), proxyUrl, version = null, client, quiet = false, onRevoked, announce = true
+} = {}) {
+  if (!node) throw new Error('startContentAgent: node is required')
+  const link = loadLink(dir)
+  if (!link?.iss) {
+    throw new Error('this node is not linked to a vault. Run first: dotrino-content enroll <code>')
+  }
+
+  // El node representa a la maestra que lo certificó: su huella es el `ownerId`.
+  // Se resuelve ANTES de abrir el transporte, para que la primera sesión que entre
+  // ya encuentre el despachador armado.
+  const owner = await pubkeyId(link.iss)
+  node.owner = owner
+  const dispatch = createOps(node, { owner, version })
+
+  const agent = await startRemoteAgent({
+    dir,
+    proxyUrl,
+    client,
+    quiet,
+    onRevoked,
+    onSession: (session) => {
+      session.on('message', (msg) => {
+        dispatch(msg)
+          .then((reply) => session.send(reply))
+          .catch((e) => session.send({ rid: msg?.rid, ok: false, code: 'failed', error: e.message }))
+      })
+    }
+  })
+
+  if (!quiet) console.log(`[content] control plane ready · owner ${owner.slice(0, 16)}`)
+
+  // ANUNCIO (§3.1): sin esto el node es administrable por sus dueños pero
+  // INVISIBLE para quien recibe un enlace — la referencia nombra al dueño, y hay
+  // que poder pasar de ahí a «qué nodes suyos están vivos». Reusa la conexión del
+  // middleware: nunca se abre una segunda.
+  const beacon = announce && agent.client
+    ? startAnnounce({ client: agent.client, owner, quiet })
+    : null
+  // LECTURA PÚBLICA por la red (§16): un tercero con el enlace pide el `cid` en un
+  // mensaje suelto y recibe solo lo marcado público. Sin esto, anunciarse no sirve
+  // de nada: el enlace nombraría a un node que no contesta a nadie.
+  const fetcher = agent.client ? startPublicFetch({ client: agent.client, node, quiet }) : null
+
+  return {
+    ...agent,
+    owner,
+    channels: () => beacon?.channels() || [],
+    served: () => fetcher?.served() || 0,
+    close () {
+      try { fetcher?.close() } catch (_) {}
+      try { beacon?.close() } catch (_) {}
+      agent.close()
+    }
+  }
+}
+
+export default { startContentAgent, isLinked, linkDir }

package/src/announce.js

@@ -0,0 +1,138 @@
+/**
+ * announce.js — ANUNCIO del node (DISENO.md §3.1). Es lo que hace que se sepa
+ * **dónde** está el contenido de un dueño.
+ *
+ * La referencia compartible nombra al DUEÑO, no a la máquina (`ownerId + cid`), así
+ * que resolverla es contestar «¿qué nodes de este dueño están vivos ahora mismo?».
+ * Hay dos caminos, según quién pregunte, y este archivo es el segundo:
+ *
+ *  - **El dueño** pregunta a su bóveda (`listAgentsByLabel(id, 'content')`): sus
+ *    aparatos y sus direcciones. No necesita ningún anuncio.
+ *  - **Un tercero con el enlace** no puede consultar la bóveda de nadie — ni debe.
+ *    Para él, el node se publica en un **canal del proxy** y cualquiera lista quién
+ *    está dentro. Eso es esto.
+ *
+ * **El nombre del canal lleva el `ownerId`, no el `cid`.** Un canal por contenido
+ * filtraría qué guarda cada quien con solo mirar la lista de canales; y además
+ * serían miles. Con uno por dueño, lo que se sabe al listar es «este dueño tiene
+ * nodes en línea», que es justo lo que hace falta para pedirle algo.
+ *
+ * **Por qué el canal va con id de proxio delante.** Hay dos proxios federados y un
+ * canal SIN prefijo es local a cada uno: el node anunciado en uno sería invisible
+ * para quien esté conectado al otro. Se publica en el canal de **cada nodo
+ * conocido** y se lista en todos, en vez de elegir uno "dueño" por una fórmula: la
+ * lista de nodos de la malla cambia cuando entra o sale un proxio, y una fórmula
+ * que dependa de ella reasigna todos los canales el día que eso pase. Son dos
+ * canales hoy; publicar en los dos cuesta dos mensajes y no se rompe nunca.
+ *
+ * **Anunciarse NO da acceso a nada.** Es una guía de teléfonos: dice a quién
+ * llamar. Quién puede pedir qué lo siguen decidiendo la ACL y el certificado, en
+ * el sitio de siempre.
+ */
+
+import { channelFor } from '../lib/public.js'
+
+/** Nombre del canal de un dueño dentro de un proxio concreto (vive en la lib: el cliente del tercero lo necesita igual). */
+export { channelFor }
+
+/** Cada cuánto se re-publica (el proxio caduca las entradas de canal). */
+export const REPUBLISH_MS = 4 * 60 * 1000
+
+/**
+ * Publica este node en el canal de su dueño, en todos los proxios conocidos, y lo
+ * mantiene publicado. Best-effort a propósito: si el proxy está caído, el node
+ * sigue funcionando —sirve en local y atiende a los aparatos del acta— y el
+ * siguiente tic lo vuelve a intentar. Un anuncio perdido no rompe nada; lo único
+ * que pasa es que un tercero no lo encuentra hasta que vuelva.
+ *
+ * @param {{ client: any, owner: string, quiet?: boolean, intervalMs?: number }} opts
+ *   client: el `WebSocketProxyClient` YA conectado del agente (`ra.client`) — no se
+ *   abre otro: dos conexiones del mismo aparato son dos identidades de transporte.
+ * @returns {{ channels: () => string[], close: () => void }}
+ */
+export function startAnnounce ({ client, owner, quiet = false, intervalMs = REPUBLISH_MS }) {
+  if (!client) throw new Error('startAnnounce: client is required')
+  if (!owner) throw new Error('startAnnounce: owner is required')
+
+  let stopped = false
+  let current = []
+
+  /** Los proxios donde hay que anunciarse: el que nos atiende y los que conoce. */
+  const targets = () => {
+    const known = Array.isArray(client.knownNodes) ? client.knownNodes : []
+    return known.length ? known : (client.node ? [client.node] : [])
+  }
+
+  async function publishAll () {
+    if (stopped) return
+    const names = targets().map((n) => channelFor(n, owner))
+    if (!names.length) return          // aún sin `connected`: el próximo tic
+    const done = []
+    for (const name of names) {
+      try {
+        await client.publish(name, { app: 'content', owner })
+        done.push(name)
+      } catch (e) {
+        if (!quiet) console.error(`[content] could not announce on ${name}: ${e.message}`)
+      }
+    }
+    // Se avisa cuando CAMBIA en cuántos proxios está anunciado, no solo la primera vez.
+    // Antes solo hablaba al pasar de 0 a algo, así que un arranque que solo alcanzó uno de
+    // los dos decía «en 1 proxio(s)» y se callaba para siempre — aunque el tic siguiente ya
+    // estuviera en los dos. Leyendo ese log parecía una federación rota que no lo estaba.
+    const changed = done.length !== current.length
+    current = done
+    if (changed && !quiet) console.log(`[content] announced as node for ${owner.slice(0, 16)} on ${done.length} proxio(s) · token ${client.token}`)
+  }
+
+  publishAll()
+  // Re-publicar al reconectar: el token cambia y el anuncio viejo apunta a una
+  // conexión que ya no existe. Sin esto, un corte de red deja al node listado y
+  // mudo, que es peor que no estar listado.
+  const offToken = client.on('token', () => { current = []; publishAll() })
+  const timer = setInterval(publishAll, intervalMs)
+  timer.unref?.()
+
+  return {
+    channels: () => [...current],
+    close () {
+      stopped = true
+      clearInterval(timer)
+      try { offToken?.() } catch (_) {}
+      for (const name of current) { try { client.unpublish(name) } catch (_) {} }
+      current = []
+    }
+  }
+}
+
+/**
+ * Lado del que BUSCA: los tokens de los nodes de un dueño que están en línea, en
+ * todos los proxios conocidos, sin repetidos.
+ *
+ * Lo que devuelve son **candidatos, no autoridades**: cualquiera puede publicarse
+ * en el canal de cualquier dueño (el nombre del canal no es un secreto). Quien
+ * pregunte tiene que comprobar las dos cosas de siempre — que el node presenta un
+ * certificado que encadena a ese `ownerId`, y que los bytes que entrega hashean al
+ * `cid` pedido. Con esas dos, un impostor en la lista no consigue nada más que
+ * gastar un intento.
+ *
+ * @param {{ client: any, owner: string }} opts
+ * @returns {Promise<string[]>} tokens (direcciones en el proxy)
+ */
+export async function findNodes ({ client, owner }) {
+  if (!client || !owner) throw new Error('findNodes: client and owner are required')
+  const known = Array.isArray(client.knownNodes) && client.knownNodes.length
+    ? client.knownNodes
+    : (client.node ? [client.node] : [])
+  const out = new Set()
+  for (const nodeId of known) {
+    try {
+      for (const token of await client.list(channelFor(nodeId, owner))) out.add(token)
+    } catch (_) { /* un proxio que no contesta no invalida al otro */ }
+  }
+  // El propio que pregunta puede estar en la lista (una PWA que también es node).
+  if (client.token) out.delete(client.token)
+  return [...out]
+}
+
+export default { startAnnounce, findNodes, channelFor, REPUBLISH_MS }

package/src/blobstore-s3.js

@@ -0,0 +1,177 @@
+/**
+ * El almacén con BUCKET detrás (DISENO.md §15).
+ *
+ * Misma interfaz que `BlobStore` —`put`, `read`, `sizeOf`, `remove`— para que ni la API
+ * local, ni el plano de control, ni el puerto de vistas previas se enteren de dónde
+ * salen los bytes. Lo que cambia es de dónde salen:
+ *
+ *     disco (caché)  →  si está, sale de aquí, y así es como se sirve casi siempre
+ *     bucket         →  si no, se jala mientras se sirve y se deja la copia
+ *
+ * Tres cosas que no son detalles:
+ *
+ *  · **Se escribe primero en local y se responde.** La subida al bucket va detrás, y
+ *    hasta que el bucket confirma, ese blob NO es desalojable (`remote`, §15.11). Un
+ *    pendiente que no logra subir se reintenta y se reporta; no se olvida.
+ *  · **Público y privado son buckets distintos** y con credenciales distintas (§15.1).
+ *    Cuál toca lo dice el ACL del blob, y quien lo sabe es el índice — por eso `put` y
+ *    `upload` reciben `isPublic` en vez de adivinarlo.
+ *  · **Una lectura parcial NO puebla la caché.** Cachear trozos sueltos dejaría
+ *    agujeros que luego parecen un blob completo.
+ */
+import { createWriteStream } from 'node:fs'
+import { mkdir, rename, rm } from 'node:fs/promises'
+import path from 'node:path'
+import { Readable } from 'node:stream'
+import { pipeline } from 'node:stream/promises'
+import { PassThrough } from 'node:stream'
+import { BlobStore, isValidCid } from './blobstore.js'
+import { S3Bucket, S3Error } from './s3.js'
+
+/** Lo que se le pone a un objeto público: es inmutable por construcción (§15.2). */
+const IMMUTABLE = 'public, max-age=31536000, immutable'
+
+/** Del `cid` a la clave del objeto. Sin prefijos: el bucket ya separa público de privado. */
+const keyOf = (cid) => {
+  if (!isValidCid(cid)) throw new Error(`invalid cid: ${cid}`)
+  return cid
+}
+
+export class S3BlobStore {
+  /**
+   * @param {object} o
+   * @param {string} o.root directorio de la CACHÉ (el mismo árbol `blobs/` de siempre)
+   * @param {S3Bucket} o.priv bucket privado (obligatorio: es donde va todo lo cifrado)
+   * @param {S3Bucket|null} [o.pub] bucket público; sin él, lo público viaja por la red (§15.3)
+   * @param {(m:string)=>void} [o.log]
+   */
+  constructor ({ root, priv, pub = null, log = () => {} }) {
+    if (!priv) throw new Error('S3BlobStore: the private bucket is missing')
+    this.cache = new BlobStore(root)
+    this.priv = priv
+    this.pub = pub
+    this.log = log
+    /** Hay una segunda copia detrás: el GC puede desalojar en vez de destruir (§15.11). */
+    this.backed = true
+  }
+
+  async init () {
+    await this.cache.init()
+    return this
+  }
+
+  /** El bucket que le toca a un blob según su ACL. */
+  bucketFor (isPublic) {
+    if (!isPublic) return this.priv
+    if (!this.pub) throw new Error('this node has no public bucket (CONTENT_S3_BUCKET_PUBLIC)')
+    return this.pub
+  }
+
+  /** La URL pública de un blob, o `null` si este node no publica por bucket. */
+  urlFor (cid, baseUrl) {
+    return baseUrl ? `${String(baseUrl).replace(/\/+$/, '')}/${keyOf(cid)}` : null
+  }
+
+  pathFor (cid) { return this.cache.pathFor(cid) }
+
+  /** Guarda en la caché. La subida al bucket la lanza el node después (`upload`). */
+  async put (readable, opts) {
+    return this.cache.put(readable, opts)
+  }
+
+  /**
+   * Sube al bucket que le toca y **confirma**. Quien llama es el único que puede marcar
+   * `remote`, y solo con lo que devuelve esto: marcar al lanzar la subida es
+   * exactamente el error que deja perder contenido.
+   *
+   * @param {string} cid
+   * @param {{ size: number, mime?: string, public?: boolean }} meta
+   */
+  async upload (cid, { size, mime, public: isPublic = false }) {
+    const bucket = this.bucketFor(isPublic)
+    const body = this.cache.read(cid)
+    await bucket.put(keyOf(cid), Readable.toWeb(body), {
+      sha256: cid.slice('sha256-'.length),
+      size,
+      contentType: mime || 'application/octet-stream',
+      // Solo lo público lleva cabecera de caché: es lo único que sirve un CDN.
+      ...(isPublic ? { cacheControl: IMMUTABLE } : {})
+    })
+    return { cid, remote: true }
+  }
+
+  /** ¿Está en la caché de esta máquina? (no pregunta al bucket: eso cuesta una petición) */
+  async sizeOf (cid) {
+    return this.cache.sizeOf(cid)
+  }
+
+  /**
+   * Lee. Si está en la caché sale de ahí; si no, se jala del bucket **mientras se
+   * sirve** y se deja la copia — salvo que sea una lectura parcial.
+   *
+   * Devuelve un stream, como el de disco, para que quien llama no cambie.
+   *
+   * @param {string} cid
+   * @param {{ start: number, end: number }} [range] inclusivo
+   * @param {{ public?: boolean }} [opts] de qué bucket, si hay que ir a buscarlo
+   */
+  read (cid, range, { public: isPublic = false } = {}) {
+    const out = new PassThrough()
+    this.cache.sizeOf(cid).then(async (size) => {
+      if (size !== null) return pipeline(this.cache.read(cid, range), out)
+
+      const bucket = this.bucketFor(isPublic)
+      const { body } = await bucket.get(keyOf(cid), range || null)
+      const src = Readable.fromWeb(/** @type {any} */ (body))
+
+      // Parcial: se sirve y se olvida. Guardar un trozo dejaría en la caché algo que
+      // parece el blob entero y no lo es.
+      if (range) { src.pipe(out); return }
+
+      // Entero: el mismo stream va a DOS destinos —quien pidió y el disco—, y solo al
+      // terminar bien se pone en su sitio. Si la descarga se corta, no queda medio blob
+      // con el nombre bueno, que luego se serviría como si estuviera completo.
+      const dest = this.cache.pathFor(cid)
+      const tmp = dest + '.dl'
+      await mkdir(path.dirname(dest), { recursive: true })
+      const disk = createWriteStream(tmp)
+      src.pipe(out)
+      src.pipe(disk)
+      disk.on('finish', () => { rename(tmp, dest).catch(() => rm(tmp, { force: true })) })
+      src.on('error', () => { disk.destroy(); rm(tmp, { force: true }).catch(() => {}) })
+    }).catch((e) => out.destroy(e))
+    return out
+  }
+
+  /**
+   * Los primeros `n` bytes. Es lo que necesita el puerto público para comprobar el tipo
+   * REAL de una imagen por sus bytes mágicos (§7.2) — y existe en la interfaz porque
+   * con bucket detrás no hay ninguna ruta de disco que abrir.
+   */
+  async readHead (cid, n, { public: isPublic = false } = {}) {
+    const local = await this.cache.sizeOf(cid)
+    if (local !== null) return this.cache.readHead(cid, n)
+    return this.bucketFor(isPublic).head(keyOf(cid), n)
+  }
+
+  /** Suelta la copia local y deja la del bucket (desalojar, §15.11). */
+  async evict (cid) {
+    await this.cache.remove(cid)
+  }
+
+  /** Borra de verdad: de la caché y del bucket. Caducar y despublicar pasan por aquí. */
+  async remove (cid, { public: isPublic = null } = {}) {
+    await this.cache.remove(cid)
+    // Sin saber su ACL se borra de los dos: es idempotente y borrar lo que no está no
+    // es un error. Más vale una petición de más que dejar un objeto huérfano pagando.
+    const buckets = isPublic === null ? [this.priv, this.pub] : [this.bucketFor(isPublic)]
+    for (const b of buckets) {
+      if (!b) continue
+      try { await b.remove(keyOf(cid)) } catch (e) {
+        if (!(e instanceof S3Error) || e.status !== 404) throw e
+      }
+    }
+  }
+}
+
+export default { S3BlobStore }

package/src/blobstore.js

@@ -0,0 +1,139 @@
+/**
+ * Almacén de blobs direccionado por contenido (Fase 1, DISENO.md §3).
+ *
+ * - `cid = sha256-<hex>` (prefijo de algoritmo → extensible a blake3 después).
+ *   Se usa SHA-256 de `node:crypto` porque no requiere dependencias nativas
+ *   (el `.npmrc` del ecosistema bloquea los build scripts de npm).
+ * - Disco: `blobs/<aa>/<bb>/<cid>` (sharding por los 4 primeros hex del hash).
+ * - Escritura por streaming: se hashea MIENTRAS se escribe a un tmp y al final
+ *   se renombra al path definitivo (dedup gratis: si ya existe, se descarta).
+ */
+import { createHash, randomBytes } from 'node:crypto'
+import { createWriteStream, createReadStream } from 'node:fs'
+import { mkdir, open, rename, rm, stat } from 'node:fs/promises'
+import { pipeline } from 'node:stream/promises'
+import { Transform } from 'node:stream'
+import path from 'node:path'
+
+const CID_RE = /^sha256-[0-9a-f]{64}$/
+
+export function isValidCid (cid) {
+  return typeof cid === 'string' && CID_RE.test(cid)
+}
+
+export class BlobStore {
+  /** @param {string} root directorio raíz de datos (contiene blobs/ y tmp/) */
+  constructor (root) {
+    this.root = root
+    this.blobsDir = path.join(root, 'blobs')
+    this.tmpDir = path.join(root, 'tmp')
+    /**
+     * ¿Hay una segunda copia detrás (un bucket)? Aquí no: el disco es la única
+     * copia, así que soltar un blob es destruirlo y el GC se comporta como
+     * siempre (DISENO.md §15.11).
+     */
+    this.backed = false
+  }
+
+  /** Prepara los directorios. Devuelve `this` para poder encadenar, como el resto. */
+  async init () {
+    await mkdir(this.blobsDir, { recursive: true })
+    await mkdir(this.tmpDir, { recursive: true })
+    return this
+  }
+
+  /** Path en disco de un cid (no comprueba existencia). */
+  pathFor (cid) {
+    if (!isValidCid(cid)) throw new Error(`invalid cid: ${cid}`)
+    const hex = cid.slice('sha256-'.length)
+    return path.join(this.blobsDir, hex.slice(0, 2), hex.slice(2, 4), cid)
+  }
+
+  /** ¿Existe el blob en disco? → size o null. */
+  async sizeOf (cid) {
+    try {
+      const st = await stat(this.pathFor(cid))
+      return st.size
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Guarda un stream hasheando al vuelo.
+   * @param {import('node:stream').Readable} readable
+   * @param {{ maxBytes?: number }} [opts] límite duro de tamaño (corta el stream)
+   * @returns {Promise<{ cid: string, size: number, existed: boolean }>}
+   */
+  async put (readable, opts = {}) {
+    const tmp = path.join(this.tmpDir, `up-${randomBytes(8).toString('hex')}`)
+    const hash = createHash('sha256')
+    let size = 0
+    const meter = new Transform({
+      transform (chunk, _enc, cb) {
+        size += chunk.length
+        if (opts.maxBytes && size > opts.maxBytes) {
+          cb(Object.assign(new Error('blob too large'), { code: 'ETOOBIG' }))
+          return
+        }
+        hash.update(chunk)
+        cb(null, chunk)
+      }
+    })
+    try {
+      await pipeline(readable, meter, createWriteStream(tmp))
+      const cid = `sha256-${hash.digest('hex')}`
+      const dest = this.pathFor(cid)
+      if (await this.sizeOf(cid) !== null) {
+        // dedup: ya lo teníamos, descartar el tmp
+        await rm(tmp, { force: true })
+        return { cid, size, existed: true }
+      }
+      await mkdir(path.dirname(dest), { recursive: true })
+      await rename(tmp, dest)
+      return { cid, size, existed: false }
+    } catch (err) {
+      await rm(tmp, { force: true })
+      throw err
+    }
+  }
+
+  /**
+   * Stream de lectura, con rango opcional [start, end] inclusivo.
+   * @returns {import('node:fs').ReadStream}
+   */
+  read (cid, range) {
+    const p = this.pathFor(cid)
+    return range
+      ? createReadStream(p, { start: range.start, end: range.end })
+      : createReadStream(p)
+  }
+
+  /**
+   * Los primeros `n` bytes de un blob. Existe para que el puerto público compruebe el
+   * tipo REAL de una imagen por sus bytes mágicos (§7.2) **sin abrir el archivo por su
+   * ruta**: con un bucket detrás no hay ruta que abrir, así que olfatear tiene que ser
+   * una operación del almacén y no de quien lo usa.
+   */
+  async readHead (cid, n) {
+    const fh = await open(this.pathFor(cid), 'r')
+    try {
+      const buf = Buffer.alloc(n)
+      const { bytesRead } = await fh.read(buf, 0, n, 0)
+      return buf.subarray(0, bytesRead)
+    } finally { await fh.close() }
+  }
+
+  async remove (cid) {
+    await rm(this.pathFor(cid), { force: true })
+  }
+
+  /**
+   * Suelta la copia LOCAL y deja la de atrás. Sin bucket detrás no hay copia de
+   * atrás, así que esto es exactamente `remove` — y por eso el node comprueba
+   * `backed` antes de llamarlo: con este backend, desalojar es destruir.
+   */
+  async evict (cid) {
+    return this.remove(cid)
+  }
+}