@dotrino/content 0.3.13

package/src/s3.js

@@ -0,0 +1,257 @@
+/**
+ * Cliente S3 mínimo, sin SDK (DISENO.md §15.10).
+ *
+ * Habla el protocolo, no un proveedor: **R2, Backblaze, Hetzner, Storj y el propio
+ * S3 de Amazon son el mismo código** con otro `endpoint`. Por eso no hay una
+ * "integración de Cloudflare" y otra "de S3": es una sola.
+ *
+ * Sin dependencias, como toda la Fase 1: `node:crypto` para firmar y `fetch` para
+ * hablar. El `.npmrc` del ecosistema bloquea los scripts de instalación, y el SDK
+ * oficial son decenas de paquetes para hacer un `PUT`.
+ *
+ * **El detalle que hace esto barato:** S3 exige mandar el SHA-256 del cuerpo en
+ * `x-amz-content-sha256`… y aquí el `cid` YA ES ese hash (`sha256-<hex>`), porque los
+ * bytes que se suben son exactamente los que el `cid` direcciona. Así que se firma sin
+ * leer el cuerpo dos veces y sin tenerlo entero en memoria: se sube en streaming.
+ */
+import { createHmac, createHash } from 'node:crypto'
+
+const ALGO = 'AWS4-HMAC-SHA256'
+const EMPTY_SHA256 = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
+
+const sha256hex = (data) => createHash('sha256').update(data).digest('hex')
+const hmac = (key, data) => createHmac('sha256', key).update(data, 'utf8').digest()
+
+/**
+ * Codificación de URI de AWS: es la de RFC 3986, que NO es la de `encodeURIComponent`
+ * (deja pasar `!'()*`). Una sola diferencia hace que la firma no cuadre y el error que
+ * devuelve el servidor no dice cuál.
+ */
+export function uriEncode (str, encodeSlash = true) {
+  let out = ''
+  for (const ch of Buffer.from(String(str), 'utf8')) {
+    const c = String.fromCharCode(ch)
+    if (/[A-Za-z0-9\-._~]/.test(c)) out += c
+    else if (c === '/') out += encodeSlash ? '%2F' : '/'
+    else out += '%' + ch.toString(16).toUpperCase().padStart(2, '0')
+  }
+  return out
+}
+
+/** `20150830T123600Z` y `20150830` a partir de una fecha. */
+export function amzDate (date) {
+  const iso = date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '')
+  return { amz: iso, day: iso.slice(0, 8) }
+}
+
+/**
+ * Firma una petición con SigV4 y devuelve las cabeceras que hay que mandar.
+ *
+ * @param {object} o
+ * @param {string} o.method
+ * @param {string|URL} o.url
+ * @param {Record<string,string>} [o.headers] las que ya lleva (se firman todas)
+ * @param {string} [o.payloadHash] hex del SHA-256 del cuerpo; por defecto, cuerpo vacío
+ * @param {string} o.accessKeyId
+ * @param {string} o.secretAccessKey
+ * @param {string} o.region
+ * @param {string} [o.service] `s3` salvo en los vectores de prueba de AWS
+ * @param {Date} [o.now]
+ * @returns {Record<string,string>} cabeceras completas, con `authorization`
+ */
+export function signRequest ({
+  method, url, headers = {}, payloadHash = EMPTY_SHA256,
+  accessKeyId, secretAccessKey, region, service = 's3', now = new Date()
+}) {
+  const u = new URL(url)
+  const { amz, day } = amzDate(now)
+
+  // Las cabeceras firmadas van en minúsculas y ordenadas; `host` y la fecha son
+  // obligatorias, y en S3 también el hash del cuerpo.
+  const all = { ...headers, host: u.host, 'x-amz-date': amz }
+  if (service === 's3') all['x-amz-content-sha256'] = payloadHash
+  const names = Object.keys(all).map((k) => k.toLowerCase()).sort()
+  const lower = Object.fromEntries(Object.entries(all).map(([k, v]) => [k.toLowerCase(), String(v).trim()]))
+
+  const canonicalHeaders = names.map((n) => `${n}:${lower[n]}\n`).join('')
+  const signedHeaders = names.join(';')
+
+  const query = [...u.searchParams.entries()]
+    .map(([k, v]) => [uriEncode(k), uriEncode(v)])
+    .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+    .map(([k, v]) => `${k}=${v}`)
+    .join('&')
+
+  const canonicalRequest = [
+    method.toUpperCase(),
+    uriEncode(decodeURIComponent(u.pathname), false),
+    query,
+    canonicalHeaders,
+    signedHeaders,
+    payloadHash
+  ].join('\n')
+
+  const scope = `${day}/${region}/${service}/aws4_request`
+  const stringToSign = [ALGO, amz, scope, sha256hex(canonicalRequest)].join('\n')
+
+  const kDate = hmac(`AWS4${secretAccessKey}`, day)
+  const kRegion = hmac(kDate, region)
+  const kService = hmac(kRegion, service)
+  const kSigning = hmac(kService, 'aws4_request')
+  const signature = createHmac('sha256', kSigning).update(stringToSign, 'utf8').digest('hex')
+
+  return {
+    ...all,
+    authorization: `${ALGO} Credential=${accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`,
+    // Se devuelven para poder diagnosticar una firma que no cuadra: el servidor
+    // contesta "SignatureDoesNotMatch" y nada más, así que sin esto no hay por dónde.
+    _canonicalRequest: canonicalRequest,
+    _stringToSign: stringToSign
+  }
+}
+
+/** Error de S3 con el código que devolvió el servidor (`NoSuchKey`, `AccessDenied`…). */
+export class S3Error extends Error {
+  constructor (status, code, message, key) {
+    super(`S3 ${status} ${code}${key ? ` (${key})` : ''}: ${message}`)
+    this.name = 'S3Error'
+    this.status = status
+    this.code = code
+  }
+}
+
+/** El cuerpo de error de S3 es XML; solo interesan dos etiquetas. */
+const parseError = (xml) => ({
+  code: /<Code>([^<]+)<\/Code>/.exec(xml)?.[1] || 'Unknown',
+  message: /<Message>([^<]+)<\/Message>/.exec(xml)?.[1] || xml.slice(0, 200)
+})
+
+/**
+ * Un bucket. Se crea uno por bucket (público y privado tienen credenciales
+ * distintas a propósito, §15.1), y no guarda estado: cada petición se firma sola.
+ */
+export class S3Bucket {
+  /**
+   * @param {object} o
+   * @param {string} o.endpoint p.ej. `https://<id>.r2.cloudflarestorage.com`
+   * @param {string} o.bucket
+   * @param {string} o.accessKeyId
+   * @param {string} o.secretAccessKey
+   * @param {string} [o.region] `auto` en R2
+   * @param {typeof fetch} [o.fetch] inyectable para la prueba de integración
+   */
+  constructor ({ endpoint, bucket, accessKeyId, secretAccessKey, region = 'auto', fetch: f = fetch }) {
+    if (!endpoint || !bucket || !accessKeyId || !secretAccessKey) {
+      throw new Error('S3Bucket: missing endpoint, bucket or credentials')
+    }
+    this.base = `${String(endpoint).replace(/\/+$/, '')}/${bucket}`
+    this.bucket = bucket
+    this.region = region
+    this.accessKeyId = accessKeyId
+    this.secretAccessKey = secretAccessKey
+    this.fetch = f
+  }
+
+  /** URL de un objeto (path-style: es lo que entienden todos los proveedores). */
+  urlFor (key) {
+    return `${this.base}/${key.split('/').map((s) => uriEncode(s)).join('/')}`
+  }
+
+  /**
+   * @private
+   * @param {string} method
+   * @param {string} key
+   * @param {{ headers?: Record<string,string>, body?: any, payloadHash?: string,
+   *           contentLength?: number|null }} [opts]
+   */
+  async request (method, key, { headers = {}, body = null, payloadHash = '', contentLength = null } = {}) {
+    const url = this.urlFor(key)
+    const h = signRequest({
+      method,
+      url,
+      headers,
+      payloadHash: payloadHash || EMPTY_SHA256,
+      accessKeyId: this.accessKeyId,
+      secretAccessKey: this.secretAccessKey,
+      region: this.region
+    })
+    delete h._canonicalRequest
+    delete h._stringToSign
+    if (contentLength != null) h['content-length'] = String(contentLength)
+
+    const res = await this.fetch(url, {
+      method,
+      headers: h,
+      body,
+      // Node lo exige para mandar un cuerpo en streaming; sin esto hay que
+      // tener el archivo entero en memoria, que es justo lo que se evita.
+      ...(body && typeof body !== 'string' ? { duplex: 'half' } : {})
+    })
+    return res
+  }
+
+  /**
+   * Sube un objeto. `sha256` es el hex del contenido — que aquí es el `cid` sin su
+   * prefijo, así que no hay que calcular nada.
+   * @param {string} key
+   * @param {any} body stream o buffer
+   * @param {{ sha256?: string, size?: number, contentType?: string, cacheControl?: string }} [o]
+   */
+  async put (key, body, { sha256 = '', size = 0, contentType = '', cacheControl = '' } = {}) {
+    if (!sha256) throw new Error('S3Bucket.put: the sha256 of the content is required')
+    /** @type {Record<string,string>} */
+    const headers = {}
+    if (contentType) headers['content-type'] = contentType
+    if (cacheControl) headers['cache-control'] = cacheControl
+    const res = await this.request('PUT', key, { headers, body, payloadHash: sha256, contentLength: size })
+    if (!res.ok) {
+      const { code, message } = parseError(await res.text())
+      throw new S3Error(res.status, code, message, key)
+    }
+    return { etag: res.headers.get('etag') }
+  }
+
+  /**
+   * Descarga un objeto. `range` es `{ start, end }` inclusivo, igual que en el
+   * BlobStore, para que el 206 de la API local siga funcionando igual.
+   * @returns {Promise<{ body: ReadableStream, size: number|null, contentType: string|null }>}
+   */
+  async get (key, range = null) {
+    const headers = range ? { range: `bytes=${range.start}-${range.end}` } : {}
+    const res = await this.request('GET', key, { headers })
+    if (!res.ok) {
+      const { code, message } = parseError(await res.text())
+      throw new S3Error(res.status, code, message, key)
+    }
+    const len = res.headers.get('content-length')
+    return { body: res.body, size: len == null ? null : Number(len), contentType: res.headers.get('content-type') }
+  }
+
+  /** Los primeros `n` bytes, que es lo que necesita olfatear un tipo de imagen (§7.2). */
+  async head (key, n) {
+    const { body } = await this.get(key, { start: 0, end: n - 1 })
+    const chunks = []
+    for await (const c of body) chunks.push(Buffer.from(c))
+    return Buffer.concat(chunks)
+  }
+
+  /** Tamaño del objeto, o `null` si no está. No baja el cuerpo. */
+  async size (key) {
+    const res = await this.request('HEAD', key)
+    if (res.status === 404) return null
+    if (!res.ok) throw new S3Error(res.status, 'HeadFailed', res.statusText, key)
+    const len = res.headers.get('content-length')
+    return len == null ? null : Number(len)
+  }
+
+  /** Borra. Borrar lo que no está NO es un error (igual que `rm -f`). */
+  async remove (key) {
+    const res = await this.request('DELETE', key)
+    if (!res.ok && res.status !== 404) {
+      const { code, message } = parseError(await res.text())
+      throw new S3Error(res.status, code, message, key)
+    }
+  }
+}
+
+export default { S3Bucket, signRequest, uriEncode, amzDate, S3Error }

package/src/server.js

@@ -0,0 +1,142 @@
+/**
+ * API HTTP local (Fase 1, DISENO.md §6). SOLO localhost: sin auth todavía
+ * (la auth por vault llega en Fase 2; la exposición al mundo en Fase 3).
+ *
+ *   POST   /c            subir (streaming; Content-Type = mime; ?ttl=<ms>)
+ *   GET    /c/<cid>      descargar/streamear (Range → 206; ETag = cid, immutable)
+ *   HEAD   /c/<cid>      size/mime/etag sin cuerpo
+ *   DELETE /c/<cid>      borrar
+ *   GET    /list         índice
+ *   POST   /pin/<cid>    retención (evita GC)     POST /unpin/<cid>
+ *   POST   /public/<cid>  publicar (al bucket público si lo hay)  POST /private/<cid>
+ *   GET    /stats        uso de disco, nº blobs
+ */
+import http from 'node:http'
+import { pipeline } from 'node:stream/promises'
+import { isValidCid } from './node.js'
+
+/** Parsea `Range: bytes=a-b|a-|-n` contra `size`. null = sin rango; false = inválido. */
+export function parseRange (header, size) {
+  if (!header) return null
+  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim())
+  if (!m || (m[1] === '' && m[2] === '')) return false
+  let start, end
+  if (m[1] === '') { // sufijo: últimos n bytes
+    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 }
+}
+
+const json = (res, code, obj) => {
+  const body = JSON.stringify(obj)
+  res.writeHead(code, { 'content-type': 'application/json' }).end(body)
+}
+
+/**
+ * @param {import('./node.js').ContentNode} node
+ * @returns {http.Server}
+ */
+export function createServer (node) {
+  return http.createServer(async (req, res) => {
+    try {
+      await route(node, req, res)
+    } catch (err) {
+      if (res.headersSent) { res.destroy(); return }
+      if (err.code === 'ETOOBIG') return json(res, 413, { error: 'blob too large' })
+      if (err.code === 'ENOSPC') return json(res, 507, { error: 'disk quota exceeded' })
+      json(res, 500, { error: err.message })
+    }
+  })
+}
+
+async function route (node, req, res) {
+  const url = new URL(req.url, 'http://localhost')
+  const [, top, cid] = url.pathname.split('/')
+
+  if (req.method === 'POST' && top === 'c' && !cid) {
+    const ttlMs = Number(url.searchParams.get('ttl')) || 0
+    const out = await node.put(req, {
+      mime: req.headers['content-type'] || 'application/octet-stream',
+      enc: url.searchParams.get('enc') === '1' ? 1 : 0,
+      ttl: ttlMs > 0 ? Date.now() + ttlMs : null
+    })
+    return json(res, out.existed ? 200 : 201, out)
+  }
+
+  if (top === 'c' && cid) {
+    if (!isValidCid(cid)) return json(res, 400, { error: 'invalid cid' })
+    const meta = node.stat(cid)
+    if (!meta) return json(res, 404, { error: 'not found' })
+
+    if (req.method === 'DELETE') {
+      await node.remove(cid)
+      return json(res, 200, { ok: true })
+    }
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      return json(res, 405, { error: 'method not allowed' })
+    }
+
+    const headers = {
+      'content-type': meta.mime,
+      etag: `"${cid}"`,
+      'cache-control': 'public, max-age=31536000, immutable',
+      'accept-ranges': 'bytes'
+    }
+    if (req.headers['if-none-match'] === `"${cid}"`) {
+      res.writeHead(304, headers).end()
+      return
+    }
+    const range = parseRange(req.headers.range, meta.size)
+    if (range === false) {
+      res.writeHead(416, { 'content-range': `bytes */${meta.size}` }).end()
+      return
+    }
+    if (range) {
+      headers['content-range'] = `bytes ${range.start}-${range.end}/${meta.size}`
+      headers['content-length'] = range.end - range.start + 1
+      res.writeHead(206, headers)
+    } else {
+      headers['content-length'] = meta.size
+      res.writeHead(200, headers)
+    }
+    if (req.method === 'HEAD') return res.end()
+    await pipeline(node.read(cid, range ?? undefined), res)
+    return
+  }
+
+  if (req.method === 'GET' && top === 'list') return json(res, 200, node.list())
+  if (req.method === 'GET' && top === 'stats') return json(res, 200, node.stats())
+
+  if (req.method === 'POST' && (top === 'pin' || top === 'unpin') && cid) {
+    if (!isValidCid(cid)) return json(res, 400, { error: 'invalid cid' })
+    const ok = node.pin(cid, top === 'pin')
+    return ok ? json(res, 200, { ok: true }) : json(res, 404, { error: 'not found' })
+  }
+
+  // PUBLICAR / despublicar. Existía solo por el plano de control, y eso dejaba sin poder
+  // publicar a las herramientas de la propia máquina —que es donde vive el dueño—, y sin
+  // poder probar el camino público sin montar medio ecosistema.
+  //
+  // Con bucket detrás, marcar público MUEVE los bytes al bucket público, que es otro
+  // (§15.1): por eso pasa por `node.setAcl` y no por el índice a secas.
+  if (req.method === 'POST' && (top === 'public' || top === 'private') && cid) {
+    if (!isValidCid(cid)) return json(res, 400, { error: 'invalid cid' })
+    const meta = node.stat(cid)
+    if (!meta) return json(res, 404, { error: 'not found' })
+    // Un blob CIFRADO no puede ser público, y se rechaza aquí además de en el índice:
+    // es la misma frontera del §7.2, y una frontera que solo se comprueba en un sitio
+    // acaba teniendo un camino que no pasa por ese sitio.
+    if (top === 'public' && meta.enc) return json(res, 400, { error: 'an encrypted blob cannot be public' })
+    const ok = node.setAcl(cid, top === 'public' ? 'public' : null)
+    return ok ? json(res, 200, { ok: true, acl: top === 'public' ? 'public' : null }) : json(res, 404, { error: 'not found' })
+  }
+
+  json(res, 404, { error: 'unknown route' })
+}

package/src/storage.js

@@ -0,0 +1,175 @@
+/**
+ * Qué almacén usa este node, y las comprobaciones antes de fiarse de él
+ * (DISENO.md §15.14 y §15.15).
+ *
+ * Una variable pública manda —`CONTENT_STORAGE`— y las demás solo tienen sentido si
+ * nombra un proveedor. El valor nombra a QUIÉN está detrás (`r2`, `b2`, `hetzner`,
+ * `storj`, `s3`), no al protocolo: todos hablan S3 y usan el mismo backend, pero
+ * saberlo permite poner sus valores por omisión y, sobre todo, que quien mire la
+ * consola entienda lo que lee.
+ *
+ * **Nunca arranca a medias.** Si falta algo o una comprobación falla, se queda en
+ * `local` y lo DICE. Un almacén mal configurado que parece funcionar es la peor de las
+ * tres opciones: se descubre el día que hace falta lo que se creía guardado.
+ */
+import { createHash } from 'node:crypto'
+import { BlobStore } from './blobstore.js'
+import { S3BlobStore } from './blobstore-s3.js'
+import { S3Bucket } from './s3.js'
+
+/** Proveedores que hablan S3. Solo cambian el endpoint y algún valor por omisión. */
+export const PROVIDERS = Object.freeze({
+  r2: { region: 'auto' },
+  b2: { region: 'us-west-004' },
+  hetzner: { region: 'eu-central' },
+  storj: { region: 'us-east-1' },
+  s3: { region: 'us-east-1' }
+})
+
+/** La sonda del camino público: nueve bytes que se suben y se leen por el dominio. */
+const PROBE = 'dotrino!'
+
+/** Lo que hace falta para hablar con un bucket, más lo que hace falta para el público. */
+const REQUIRED = ['CONTENT_S3_ENDPOINT', 'CONTENT_S3_BUCKET_PRIVATE', 'CONTENT_S3_KEY_ID', 'CONTENT_S3_SECRET']
+const REQUIRED_PUBLIC = ['CONTENT_S3_PUBLIC_KEY_ID', 'CONTENT_S3_PUBLIC_SECRET', 'CONTENT_PUBLIC_BASE_URL']
+
+/**
+ * Lee la configuración del entorno (que la sirve el vault, §15.14).
+ * @param {Record<string,string|undefined>} [env]
+ * @returns {{ kind: string, provider: string|null, missing: string[], region: string,
+ *             endpoint: string, priv: string, pub: string|null, baseUrl: string|null,
+ *             keyId: string, secret: string, pubKeyId: string, pubSecret: string }}
+ */
+export function storageConfig (env = process.env) {
+  const kind = (env.CONTENT_STORAGE || 'local').trim().toLowerCase()
+  if (kind === 'local') return { kind: 'local', provider: null, missing: [] , region: '', endpoint: '', priv: '', pub: null, baseUrl: null, keyId: '', secret: '', pubKeyId: '', pubSecret: '' }
+
+  const provider = PROVIDERS[kind] ? kind : null
+  const missing = REQUIRED.filter((k) => !env[k])
+
+  // El bucket público es OPCIONAL a propósito: un node puede tener bucket solo para lo
+  // privado (durabilidad) y seguir sirviendo lo público por la red (§15.3). Pero si lo
+  // declara a medias, eso sí es un error — no se publica «casi».
+  const wantsPublic = !!env.CONTENT_S3_BUCKET_PUBLIC
+  if (wantsPublic) missing.push(...REQUIRED_PUBLIC.filter((k) => !env[k]))
+
+  return {
+    kind,
+    provider,
+    missing,
+    region: env.CONTENT_S3_REGION || PROVIDERS[kind]?.region || 'us-east-1',
+    endpoint: env.CONTENT_S3_ENDPOINT || '',
+    priv: env.CONTENT_S3_BUCKET_PRIVATE || '',
+    pub: wantsPublic ? env.CONTENT_S3_BUCKET_PUBLIC : null,
+    baseUrl: env.CONTENT_PUBLIC_BASE_URL || null,
+    keyId: env.CONTENT_S3_KEY_ID || '',
+    secret: env.CONTENT_S3_SECRET || '',
+    pubKeyId: env.CONTENT_S3_PUBLIC_KEY_ID || '',
+    pubSecret: env.CONTENT_S3_PUBLIC_SECRET || ''
+  }
+}
+
+/**
+ * Las tres comprobaciones del §15.15, las que se rompen SIN DAR ERROR.
+ *
+ * @param {ReturnType<typeof storageConfig>} cfg
+ * @param {{ priv: S3Bucket, pub: S3Bucket|null }} buckets
+ * @param {typeof fetch} [f]
+ * @returns {Promise<{ ok: boolean, fatal: string[], warn: string[] }>}
+ */
+export async function checkBuckets (cfg, { priv, pub }, f = fetch) {
+  const fatal = []
+  const warn = []
+
+  // 1. El mismo bucket para las dos cosas: lo privado acabaría en el que tiene dominio.
+  if (cfg.pub && cfg.pub === cfg.priv) {
+    fatal.push('the private and public buckets are the same: encrypted blobs would land in the one with a domain')
+  }
+
+  // 2. El privado NO puede responder sin credenciales. Se pide un objeto que no existe:
+  //    un bucket cerrado contesta 400/401/403 (falta la firma o no autoriza), y uno
+  //    ABIERTO contesta 404 (no está) — que es lo que delata que cualquiera puede leer
+  //    los que sí están.
+  //
+  //    LO QUE ESTO NO VE, y hay que decirlo: si alguien conecta un DOMINIO al bucket
+  //    privado, este sondeo no se entera — pregunta al endpoint de S3, que sigue
+  //    exigiendo firma aunque el bucket tenga dominio público. Contra eso no hay API:
+  //    es responsabilidad de quien crea los buckets (§15.15).
+  try {
+    const r = await f(priv.urlFor('sha256-' + '0'.repeat(64)), { method: 'GET' })
+    if (r.status === 404 || r.ok) {
+      fatal.push(`the private bucket "${cfg.priv}" answers without credentials (HTTP ${r.status}): it is open to the world`)
+    }
+  } catch (e) {
+    warn.push(`no se pudo comprobar si el bucket privado está cerrado: ${e.message}`)
+  }
+
+  // 3. El dominio del público tiene que servir DE VERDAD, y eso no se deduce mirando
+  //    una respuesta de error: se comprueba subiendo algo y leyéndolo por el dominio.
+  //
+  //    Se intentó antes por las malas —«si el 404 viene en HTML, el dominio no es el
+  //    bucket»— y se cayó sola: GitHub Pages contesta un 404 en HTML, pero R2 TAMBIÉN
+  //    contesta el suyo en HTML. Dos cosas indistinguibles por su página de error.
+  //
+  //    La sonda es un objeto de nueve bytes, siempre el mismo (su nombre es su hash, así
+  //    que subirla dos veces no ensucia nada) y su presencia documenta que el enlace
+  //    funciona. Cuesta dos peticiones al arrancar.
+  if (pub && cfg.baseUrl) {
+    try {
+      const bytes = Buffer.from(PROBE)
+      const cid = 'sha256-' + createHash('sha256').update(bytes).digest('hex')
+      await pub.put(cid, bytes, { sha256: cid.slice(7), size: bytes.length, contentType: 'text/plain' })
+      const r = await f(`${cfg.baseUrl.replace(/\/+$/, '')}/${cid}`, { method: 'GET' })
+      const body = r.ok ? (await r.text()).trim() : ''
+      if (body !== PROBE) {
+        warn.push(`${cfg.baseUrl} no sirve lo que hay en «${cfg.pub}» (HTTP ${r.status}): revisa que el dominio esté conectado AL BUCKET desde el panel`)
+      }
+    } catch (e) {
+      warn.push(`no se pudo comprobar el camino público: ${e.message}`)
+    }
+  }
+
+  return { ok: fatal.length === 0, fatal, warn }
+}
+
+/**
+ * Monta el almacén que toca. Devuelve SIEMPRE algo utilizable: si el bucket no está o
+ * no pasa las comprobaciones, devuelve el de disco y explica por qué.
+ *
+ * @param {{ dir: string, env?: any, log?: (m:string)=>void, check?: boolean, fetch?: typeof fetch }} o
+ */
+export async function openStore ({ dir, env = process.env, log = () => {}, check = true, fetch: f = fetch }) {
+  const cfg = storageConfig(env)
+  if (cfg.kind === 'local') return { store: await new BlobStore(dir).init(), cfg }
+
+  if (!cfg.provider) {
+    log(`[storage] CONTENT_STORAGE="${cfg.kind}" is not a known provider (${Object.keys(PROVIDERS).join(', ')}); staying on LOCAL`)
+    return { store: await new BlobStore(dir).init(), cfg }
+  }
+  if (cfg.missing.length) {
+    log(`[storage] ${cfg.kind} requested but these variables are missing: ${cfg.missing.join(', ')}`)
+    log('[storage] staying on LOCAL: a half-configured store is worse than none')
+    return { store: await new BlobStore(dir).init(), cfg }
+  }
+
+  const common = { endpoint: cfg.endpoint, region: cfg.region, fetch: f }
+  const priv = new S3Bucket({ ...common, bucket: cfg.priv, accessKeyId: cfg.keyId, secretAccessKey: cfg.secret })
+  const pub = cfg.pub
+    ? new S3Bucket({ ...common, bucket: cfg.pub, accessKeyId: cfg.pubKeyId, secretAccessKey: cfg.pubSecret })
+    : null
+
+  if (check) {
+    const { ok, fatal, warn } = await checkBuckets(cfg, { priv, pub }, f)
+    for (const w of warn) log(`[storage] ⚠ ${w}`)
+    if (!ok) {
+      for (const e of fatal) log(`[storage] ✖ ${e}`)
+      log('[storage] staying on LOCAL until that is fixed')
+      return { store: await new BlobStore(dir).init(), cfg }
+    }
+  }
+
+  log(`[storage] ${cfg.kind}: private "${cfg.priv}"${cfg.pub ? `, public "${cfg.pub}" at ${cfg.baseUrl}` : ' (no public bucket: public reads go over the network)'}`)
+  return { store: await new S3BlobStore({ root: dir, priv, pub, log }).init(), cfg }
+}
+
+export default { storageConfig, checkBuckets, openStore, PROVIDERS }