DEV Community: Solsticio

Measuring MP3 and MP4 durations by reading their headers

Solsticio — Sun, 01 Nov 2026 09:14:28 +0000

The video timeline for Solsticio is driven by audio. Each phrase of the voiceover is a separate MP3 file, and the composition step needs to know exactly how long each clip is to place subtitles and on-screen elements. The Fish Audio API does not return timestamps, so the script is chopped into phrases and each clip is measured individually.

The obvious approach is to shell out to ffprobe. That works, but it means shipping ffmpeg in the CI image. For a narrow case where the encoder is known, parsing the container header directly is a short, dependency-free function.

MP3: walking the frames

The MP3 parser lives in scripts/lib/tts/mp3-duration.mjs. The file header explains why the naive approach fails:

/**
 * Duración exacta de un MP3, recorriendo sus cabeceras de frame.
 *
 * Hace falta porque la línea de tiempo del vídeo la marca el audio: cada frase
 * de la locución es un mp3 y la composición necesita saber cuánto dura para
 * colocar el subtítulo y lo que pasa en pantalla. La API de Fish Audio **no
 * devuelve marcas de tiempo**, así que trocear el guion en frases y medir cada
 * clip es lo que sustituye a la alineación palabra por palabra.
 *
 * No sirve `bytes * 8 / bitrate`: eso solo vale con bitrate constante y da un
 * error acumulado con VBR. Recorrer los frames es exacto en ambos casos, y son
 * treinta líneas sin dependencias — meter ffprobe o un paquete de npm para esto
 * sería peor.
 */

// Tabla de bitrates de MPEG Layer III, en kbps, por índice de cabecera.

The bytes * 8 / bitrate formula only works with constant bitrate. With VBR, the error accumulates across the file. Walking the frames is exact in both cases.

The function starts by skipping the ID3v2 tag if present, then scans for frame sync markers. Each valid frame header contains the MPEG version, layer, bitrate index, sample rate index, and padding bit. From those fields, the frame length is computed and the duration is accumulated.

export function mp3Duration(buf) {
  let pos = id3Size(buf);
  let seconds = 0;

  while (pos + 4 <= buf.length) {
    // Sincronía: once bits a uno.
    if (buf[pos] !== 0xff || (buf[pos + 1] & 0xe0) !== 0xe0) {
      pos++;
      continue;
    }

    const versionBits = (buf[pos + 1] >> 3) & 0x03; // 3=MPEG1, 2=MPEG2, 0=MPEG2.5
    const layerBits = (buf[pos + 1] >> 1) & 0x03;   // 1 = Layer III
    const bitrateIdx = (buf[pos + 2] >> 4) & 0x0f;
    const rateIdx = (buf[pos + 2] >> 2) & 0x03;
    const padding = (buf[pos + 2] >> 1) & 0x01;

    const rates = SAMPLE_RATE[versionBits];
    if (layerBits !== 1 || !rates || rateIdx === 3 || bitrateIdx === 0 || bitrateIdx === 15) {
      pos++; // falsa sincronía
      continue;
    }

    const sampleRate = rates[rateIdx];
    const bitrate = (versionBits === 3 ? BITRATE_V1[bitrateIdx] : BITRATE_V2[bitrateIdx]) * 1000;
    // MPEG1 Layer III son 1152 muestras por frame; MPEG2 y 2.5, 576.
    const samples = versionBits === 3 ? 1152 : 576;
    const frameLen = Math.floor((samples / 8) * (bitrate / sampleRate)) + padding;
    if (frameLen <= 4) {
      pos++;
      continue;
    }

    seconds += samples / sampleRate;
    pos += frameLen;
  }

  return seconds;
}

The loop advances by the computed frame length after each valid frame. If the sync check fails or the frame length is implausibly small, it advances by one byte and keeps scanning. This handles false syncs without needing to know where the next real frame starts.

The bitrate tables cover MPEG 1 and MPEG 2 Layer III. The sample rate lookup handles three versions: MPEG 1, MPEG 2, and MPEG 2.5. MPEG 1 Layer III frames carry 1152 samples; MPEG 2 and 2.5 carry 576. The padding bit adds one byte to the frame length when set.

MP4: reading two windows

The MP4 prober is in scripts/lib/validate.mjs. It reads duration and track types by walking the file's atoms. The comment in the source says it plainly:

/**
 * Comprobaciones antes de publicar.
 *
 * Publicar es irreversible en la práctica: en Bluesky y Mastodon hay que borrar
 * a mano, y en Instagram el post ya lo ha visto quien lo haya visto. Con catorce
 * tipos de vídeo, la probabilidad de que uno salga roto (render a medias, la
 * locución cortada, un fichero de 60 MB que revienta la subida) deja de ser
 * teórica. Esto lo detiene antes, no después.
 *
 * Los límites de plataforma NO estaban codificados en ningún poster: los
 * truncados que había eran de texto, y no había una sola comprobación de tamaño
 * ni de duración. Aquí están, en un sitio, con su motivo.
 */
import { statSync, openSync, readSync, closeSync, readFileSync } from 'node:fs';
import { specFor, PLATFORMS, idDePlataforma } from './platforms.mjs';
import { captionFor, altText, longitudPublicada } from './captions.mjs';

The atoms that matter, mvhd and hdlr, live at the beginning or the end of the file. The prober reads two windows instead of the whole file, which can be 40 MB.

export function probeMp4(file) {
  const tracks = [];
  let seconds = 0;
  const fd = openSync(file, 'r');
  try {
    const size = statSync(file).size;
    // Los átomos que interesan (mvhd y hdlr) viven al principio o al final;
    // se leen dos ventanas en vez del fichero entero, que puede ser de 40 MB.
    for (const [start, len] of windows(size)) {
      const buf = Buffer.alloc(len);
      readSync(fd, buf, 0, len, start);
      for (let i = 0; i + 32 < buf.length; i++) {
        const tag = buf.toString('latin1', i, i + 4);
        if (tag === 'hdlr') {
          const kind = buf.toString('latin1', i + 12, i + 16);
          if (!tracks.includes(kind)) tracks.push(kind);
        } else if (tag === 'mvhd' && seconds === 0) {
          const version = buf[i + 4];
          const timescale = version === 1 ? Number(buf.readBigUInt64BE(i + 20)) : buf.readUInt32BE(i + 16);
          const duration = version === 1 ? Number(buf.readBigUInt64BE(i + 28)) : buf.readUInt32BE(i + 20);
          if (timescale > 0) seconds = duration / timescale;
        }
      }
    }
  } catch {
    /* fichero raro: se devuelve lo que se haya podido leer */
  } finally {
    closeSync(fd);
  }
  return { seconds, tracks };
}

The windows function returns one window if the file is small enough, otherwise two: one at the start and one at the end, each up to 512 KB. The scan looks for four-byte tags. When it finds hdlr, it reads the track kind at offset 12. When it finds mvhd and duration has not been set yet, it reads the version byte to decide between 32-bit and 64-bit timescale and duration fields.

The mvhd atom stores duration as a count of timescale units. Dividing duration by timescale gives seconds. The version byte determines whether those fields are 32-bit or 64-bit integers.

What the validators check

The prober feeds into validateVideo, which runs before publishing. The limits are explicit:

maxBytes: 45 * 1024 * 1024
minSeconds: 5
maxSeconds: 180

The 45 MB cap sits below the 50 MB Telegram bot limit. The 180 second cap stays under the Shorts cutoff and the Bluesky limit. The 5 second minimum catches renders that produced almost nothing.

The validator also checks that the MP4 has both a video track (vide) and an audio track (soun). Some platforms reject an MP4 without an audio track even if the content is silent, so the render step enforces an audio track.

A sidecar JSON file, written by the render step, records whether the piece came out with voice. If voiceOk is false, the validator adds a warning. The video is not discarded; it ships with music and subtitles. But whoever reviews it needs to know the voice is missing.

Measuring what gets published

The caption checker in validate.mjs measures the exact text that each platform will publish, not three separate fields. The comment explains the shift:

/**
 * Comprueba, RED A RED, que lo que se va a publicar cabe.
 *
 * Los posters truncan, así que nada revienta — pero un texto truncado se corta a
 * mitad de frase y se publica igual. Esto avisa ANTES, mientras es un cambio de
 * una línea en captions.mjs.
 *
 * 🔴 Antes miraba TRES textos sueltos (`short`, `alt`, `title`) contra tres
 * límites escritos a mano, y ninguno era el que se publicaba: desde que cada red
 * compone el suyo con `captionFor`, lo que hay que medir es exactamente eso. El
 * caso peliagudo sigue siendo Bluesky, donde el poster construye los facets
 * confiando en que el texto quepa en 300 grafemas.
 *
 * Se mide en GRAFEMAS y no en `.length`: un emoji son dos unidades de código y
 * las redes que cuentan de verdad cuentan grafemas.
 *
 * @returns string[] avisos (vacío si todo cabe)
 */

Before, the checker looked at short, alt, and title against three hand-written limits. None of those was what actually got published. Since each network composes its own text with captionFor, the checker measures that composed text.

Measurement is in graphemes, not .length. An emoji is two code units but one grapheme. The networks that count for real count graphemes.

The list of networks to measure is maintained by hand. The comment on that list is blunt:

/**
 * Los destinos del fan-out cuyo texto compone `captionFor`, y que por tanto hay
 * que medir.
 *
 * 🔴 Esta lista se mantiene a mano y `fanout.mjs` tiene la suya: un destino que
 * se añada allí y se olvide aquí **no se mide y nadie se entera**. El control
 * positivo no lo caza, porque demuestra que el comprobador ve lo que busca — no
 * que esté buscando en todos los sitios. Por eso hay abajo un cotejo contra el
 * catálogo de plataformas, y toda ausencia deliberada está escrita con su motivo.
 *
 * Pasó de verdad: `pinterest` (el directo, el del terreno propio) compone su
 * título y su descripción con `captionFor` desde ago-2026 y se quedó fuera de
 * esta lista. Once redes medidas de catorce destinos.
 */

A destination added to fanout.mjs and forgotten in this list does not get measured, and nobody notices. The positive control does not catch that, because it proves the checker sees what it is looking for, not that it is looking in all the places.

To close that gap, the checker reads fanout.mjs source code and extracts the destination names from the LOCAL, REMOTE, and OWN maps.

function destinosDelFanout() {
  let src;
  try {
    src = readFileSync(new URL('./fanout.mjs', import.meta.url), 'utf8');
  } catch {
    return null; // no se pudo leer: quien llama lo dice, no lo da por vacío
  }
  const nombres = new Set();
  for (const mapa of ['LOCAL', 'REMOTE', 'OWN']) {
    const i = src.indexOf(`const ${mapa} = {`);
    if (i < 0) continue;
    // Se recorre contando llaves en vez de con una regex: un `{` dentro del mapa
    // (un objeto anidado el día de mañana) cortaría la regex por donde no es.
    let prof = 0;
    let fin = i;
    for (let k = src.indexOf(`{`, i); k < src.length; k++) {
      if (src[k] === '{') prof++;
      else if (src[k] === '}') { prof--; if (prof === 0) { fin = k; break; } }
    }
    const cuerpo = src.slice(src.indexOf(`{`, i) + 1, fin);
    for (const trozo of cuerpo.split(',')) {
      const clave = trozo.split(':')[0].trim().replace(/^['"]|['"]$/g, '');
      if (/^[a-z][a-z0-9-]*$/.test(clave)) nombres.add(clave);
    }
  }
  return nombres;
}

The source is read instead of imported because the eleven posters capture their credentials in module-level constants at import time, and social-daily.mjs imports the fan-out after applyLangCreds(). Importing it here would move that import earlier and break per-language credential application.

A positive control seeds the expected set with five destinations that must be present. If the reader finds fewer, it reports that the reader is broken and the absence check is unreliable.

The checker also compares the measured list against the platform catalog. Any platform with a spec but no measurement and no documented exclusion gets flagged. The exclusions are written out one by one, with a reason. An absence without a reason is indistinguishable from an oversight, which is exactly the failure this module exists to catch.

Boundaries

The MP3 parser handles MPEG 1, 2, and 2.5 Layer III with the standard bitrate tables. It does not handle other layers or non-standard encoders. The frame walk assumes the file is a sequence of frames after the ID3 tag, with no other metadata in between.

The MP4 prober reads two windows of up to 512 KB each. If the mvhd or hdlr atoms fall outside those windows, they are not found. The prober returns whatever it managed to read; a file that produces no tracks and no duration triggers a warning in the validator rather than an error.

Both parsers use only Node.js built-in modules. No ffmpeg, no npm packages. The MP3 parser is 76 lines including comments and tables. The MP4 prober is a single function plus a small window helper. For the specific encoders and file structures these pipelines produce, that is enough.

Rating Logic Puzzles by the Deductions They Require

Solsticio — Fri, 07 Aug 2026 12:26:46 +0000

Most puzzle generators assign difficulty based on the number of starting clues or the time a brute-force solver takes. Neither metric matches human perception. A grid with few clues might resolve instantly if every move is forced by a simple pattern, while a densely populated board can stall a player who hasn't spotted a specific contradiction. Solsticio, a daily sun/moon logic puzzle, derives its rating from the actual deduction tiers a solver must use to reach a solution.

The problem with counting givens

Counting empty cells assumes that every missing piece adds equal cognitive load. This fails when a puzzle forces a player to chain multiple complex inferences versus a simple scan. Brute-force timing is equally unreliable; it measures machine speed, not human friction. A solver that backtracks aggressively finds a path quickly, but a human relying on logical deduction gets stuck on the same branch.

To align the rating with the player's experience, the generator tracks which specific techniques are required. The system defines four distinct tiers of deduction, ranging from immediate pattern recognition to hypothetical contradiction testing.

export const TIER = {
  TRIO: 1,       // completar trío bloqueado (evitar 3 iguales seguidos)
  BALANCE: 2,    // equilibrio de fila/columna casi llena
  CONNECTOR: 3,  // aplicar conector = / ×
  CONTRA1: 4,    // deducción encadenada por contradicción a 1 paso
};

These tiers are not arbitrary labels. They represent a strict hierarchy of logical complexity. Tier 1 handles local patterns like preventing three identical symbols in a row. Tier 2 manages global balance, ensuring rows and columns do not exceed half the grid size for either symbol. Tier 3 applies connector rules, where adjacent cells with specific relationships force a value. Tier 4 requires assuming a value, propagating consequences, and detecting a contradiction to prove the assumption false.

Separating the sweeps

The solver does not run a monolithic algorithm. Instead, it executes a series of "sweeps," where each pass attempts to fill cells using only one specific technique. This separation is critical for accurate scoring. If a solver mixes techniques in a single pass, it becomes impossible to know which level of logic was actually necessary to solve a specific cell.

Each sweep function iterates through the grid, checking if a cell can be filled solely by its assigned rule. If a cell is filled, the counter for that tier increments. If a sweep detects a contradiction, the solver flags the puzzle as invalid. The logic for Tier 1, which prevents trios of identical symbols, looks like this:

function sweepTrio(cells, n, connIndex) {
  let filled = 0;
  for (let i = 0; i < cells.length; i++) {
    if (cells[i] !== EMPTY) continue;
    const t0 = createsTrio(cells, n, i, 0);
    const t1 = createsTrio(cells, n, i, 1);
    if (t0 && t1) return CONTRA;
    if (t0 === t1) continue; // ninguno o ambos válidos por trío → no fuerza
    const fv = t0 ? 1 : 0;
    if (!localLegal(cells, n, i, fv, connIndex)) return CONTRA;
    cells[i] = fv;
    filled++;
  }
  return filled;
}

// Tier 2 — Equilibrio: un valor excede n/2 en fila/col ⇒ la celda toma el otro.

Notice that sweepTrio returns immediately if it finds a contradiction or if it fills a cell. It does not proceed to check balance or connectors. This isolation ensures that tierCounts accurately reflects the minimum set of tools required to solve the puzzle. The main loop in the solver orchestrates these sweeps in order of increasing complexity.

export function deductiveSolve(puzzle, { maxTier = TIER.CONTRA1 } = {}) {
  const { n, connectors = [] } = puzzle;
  const cells = (puzzle.clues || puzzle.cells).slice();
  const connIndex = buildConnIndex(connectors);
  const tierCounts = { 1: 0, 2: 0, 3: 0, 4: 0 };
  let maxUsed = 0;

  for (;;) {
    if (isComplete(cells)) break;

    let r = sweepTrio(cells, n, connIndex);
    if (r === CONTRA) return fail(cells, maxUsed, tierCounts);
    if (r > 0) { maxUsed = Math.max(maxUsed, 1); tierCounts[1] += r; continue; }

    if (maxTier >= TIER.BALANCE) {
      r = sweepBalance(cells, n, connIndex);
      if (r === CONTRA) return fail(cells, maxUsed, tierCounts);
      if (r > 0) { maxUsed = Math.max(maxUsed, 2); tierCounts[2] += r; continue; }
    }

    if (maxTier >= TIER.CONNECTOR) {
      r = sweepConnector(cells, n, connIndex);
      if (r === CONTRA) return fail(cells, maxUsed, tierCounts);
      if (r > 0) { maxUsed = Math.max(maxUsed, 3); tierCounts[3] += r; continue; }
    }

    if (maxTier >= TIER.CONTRA1) {
      r = sweepContradiction(cells, n, connIndex);
      if (r === CONTRA) return fail(cells, maxUsed, tierCounts);
      if (r > 0) { maxUsed = Math.max(maxUsed, 4); tierCounts[4] += r; continue; }
    }

    break; // atascado: no se puede avanzar solo con deducción hasta maxTier
  }

  return { solved: isComplete(cells), cells, maxTier: maxUsed, tierCounts };
}

The loop continues until the grid is complete or no further progress can be made with the allowed techniques. If the solver gets stuck, it means the puzzle requires a higher tier than currently permitted, or the puzzle is broken. By tracking maxUsed, the system knows exactly which tier was the bottleneck.

Handling the hardest cases

The most difficult puzzles require Tier 4 logic: contradiction. This is where the solver must temporarily assume a value for an empty cell, run the direct propagation rules, and see if that assumption leads to an impossible state. If it does, the original cell must hold the opposite value.

This is computationally more expensive than a simple scan, so the solver isolates it in its own function. It tries one value, runs the direct propagation engine, and checks for a contradiction signal.

function sweepContradiction(cells, n, connIndex) {
  for (let i = 0; i < cells.length; i++) {
    if (cells[i] !== EMPTY) continue;
    for (let v = 0; v < 2; v++) {
      if (!localLegal(cells, n, i, v, connIndex)) continue; // ese valor ya es ilegal por tiers 1-3
      const trial = cells.slice();
      trial[i] = v;
      if (propagateDirect(trial, n, connIndex) === 'contradiction') {
        const fv = 1 - v;
        if (!localLegal(cells, n, i, fv, connIndex)) return CONTRA;
        cells[i] = fv;
        return 1;
      }
    }
  }
  return 0;
}

// ── API pública ──────────────────────────────────────────────────────────────
// Resuelve por deducción pura (sin adivinar). `maxTier` limita la técnica más
// avanzada permitida (para generar niveles de una dificultad acotada).

The propagateDirect function is the engine that drives this check. It runs the Tier 1, 2, and 3 sweeps repeatedly until no more cells can be filled. If this process hits a contradiction, the assumption in the trial grid was wrong.

function propagateDirect(cells, n, connIndex) {
  for (;;) {
    let r = sweepTrio(cells, n, connIndex);
    if (r === CONTRA) return 'contradiction';
    if (r > 0) continue;
    r = sweepBalance(cells, n, connIndex);
    if (r === CONTRA) return 'contradiction';
    if (r > 0) continue;
    r = sweepConnector(cells, n, connIndex);
    if (r === CONTRA) return 'contradiction';
    if (r > 0) continue;
    return 'ok';
  }
}

// Tier 4 — Contradicción a 1 paso: si asumir v en una celda lleva a contradicción
// tras propagación directa, entonces la celda debe ser el otro valor.
// Rellena UNA celda y devuelve (para reiniciar por técnicas más simples después).

This structure allows the difficulty scorer to count exactly how many times a contradiction step was necessary. A puzzle that requires one contradiction is harder than one requiring none, but a puzzle requiring ten contradictions is significantly harder still. The scoring function captures this nuance.

export function scoreDifficulty(solveResult, { n, givenRatio }) {
  const { maxTier, tierCounts } = solveResult;

  let score;
  switch (maxTier) {
    case 0: score = 1; break;              // resuelto sin técnicas (casi todo dado)
    case TIER.TRIO: score = 2; break;      // solo tríos
    case TIER.BALANCE: score = 3; break;   // hasta equilibrio
    case TIER.CONNECTOR: score = 4; break; // requiere conectores
    case TIER.CONTRA1:                     // requiere contradicción encadenada
      score = 5 + Math.min(4, Math.floor((tierCounts[4] - 1) / 3)); // 5..9
      break;
    default: score = 6;
  }

  // Menos pistas ⇒ más difícil; muchas pistas ⇒ más fácil.
  if (givenRatio < 0.32) score += 1;
  if (givenRatio > 0.5) score -= 1;

  return Math.max(1, Math.min(10, score));
}

// Etiqueta legible (para UI / bench).

The score starts at a base determined by the highest tier used. If the puzzle requires Tier 4, the base is 5. It then adds points based on the number of contradiction steps found in tierCounts[4]. Finally, it adjusts the score based on the density of given clues. Fewer clues increase the score, while a high ratio of givens decreases it. The final result is clamped between 1 and 10.

Translating numbers to labels

Raw scores are useful for generation, but players need human-readable labels. The system maps the numeric score to four distinct categories.

export function difficultyLabel(score) {
  if (score <= 2) return 'Fácil';
  if (score <= 4) return 'Medio';
  if (score <= 7) return 'Difícil';
  return 'Experto';
}

A score of 2 or less is "Fácil," indicating the puzzle relies on simple patterns. "Medio" covers the range where balance and connector rules appear. "Difícil" and "Experto" capture the puzzles that force the solver into contradiction territory. This mapping ensures that a player sees "Difícil" only when the generator has confirmed the puzzle requires the specific logical steps associated with that label.

The daily puzzle generation pipeline uses these metrics to filter candidates. It generates a grid, solves it with the tiered solver, and calculates the score. If the score falls outside the target band for the day, the generator discards the grid and tries again. This process guarantees that every daily puzzle matches its intended difficulty, not by guesswork, but by the explicit logical steps a solver must take to finish it.

A daily logic puzzle with no backend at all

Solsticio — Thu, 06 Aug 2026 10:59:54 +0000

I built Solsticio, a daily sun/moon logic puzzle in the
Binairo/Takuzu family, and I set myself one engineering constraint: no backend. The daily
puzzle had to be identical for everyone — on the web, in the Android app, and in the social
videos — without a server deciding anything.

The date is the seed

The whole thing rests on a generator that is deterministic given a seed, and a seed derived
from the date:

export function specForDaily(y, m, d) {
  const base = y * 10000 + m * 100 + d;
  // First seed in [base, base+500) that yields a 6x6 board of difficulty 5..7.
  for (let s = base; s < base + 500; s++) {
    const r = generate({ n: 6, maxTier: TIER.CONTRA1 }, s);
    if (r.ok && r.difficulty >= 5 && r.difficulty <= 7) return { seed: s, n: 6 };
  }
  // Fallbacks: first solvable board, then the base seed itself.
  for (let s = base; s < base + 500; s++) {
    if (generate({ n: 6 }, s).ok) return { seed: s, n: 6 };
  }
  return { seed: base, n: 6 };
}

Same date → same seed → same board, everywhere. No coordination, no database, no clock skew
argument. The scan window exists because not every seed produces a board in the difficulty band
I want, and the fallbacks guarantee the function is total: there is always a puzzle for every
date, even a hypothetical pathological one.

"Solvable" has to mean something specific

A generator that emits a valid board isn't enough. Two extra gates run on every candidate:

Uniqueness by pure deduction. A deductiveSolve pass tries to solve the board using only
inference rules, up to a maximum technique tier. If it can't finish without guessing, the board
is rejected. This is what lets me promise "never guess" — it's not a claim about the puzzle
looking fair, it's a property checked on every board before it ships.

An aesthetics pass. Boards can be functionally valid and still unpleasant: too many givens,
a row that gives itself away, clues clumped in one corner. A separate aestheticsOk check
rejects those. It's the least glamorous part of the generator and the one that most changed how
the game feels.

The difficulty score that specForDaily filters on falls out of the solver: it's the tier of
the hardest technique the solver needed. Difficulty is measured, not assigned.

Two implementations, one algorithm

The generator is written twice: JavaScript for the website and the video pipeline, Dart for the
Flutter app. That's a duplication I'd normally avoid, but sharing a runtime across an Astro
site, a Remotion renderer and a Flutter app costs more than it saves.

The risk with two implementations is drift. If the ports disagree by one bit in the PRNG, the
app and the website show different puzzles on the same day — which breaks the one promise the
product makes. So there's a cross-determinism test that pins the Dart side against reference
vectors captured from the JS prototype: the raw mulberry32 output sequence for a known seed,
plus fully generated levels at several sizes and seeds.

✓ mulberry32(12345) matches the JS sequence
✓ generate() reproduces the JS reference levels 6x6 seed 42
✓ generate() reproduces the JS reference levels 6x6 seed 1
✓ generate() reproduces the JS reference levels 8x8 seed 7
✓ generate() reproduces the JS reference levels 6x6 conn seed 3

Being honest about the gap: that test lives in the app repo and I run it by hand. It is not yet
wired into CI, which means it protects against drift only when I remember to run it. Writing
this post is what made me go look — and it still passes, but "passes when I remember" is not a
guarantee. That's the next thing I'm fixing.

Everything else is a consumer of the same function

The website (Astro on Cloudflare Pages) prerenders one indexable URL per date, in three languages, and rebuilds itself daily in CI so "today" rolls over on its own.
The video pipeline (Remotion) renders a vertical short of the solve animation for each day, in English, Spanish and Portuguese. It uses a different seed offset on purpose, so the video doesn't spoil the actual daily.
The Flutter app computes the same spec locally, which is why it works fully offline.

None of these talk to each other. They just agree, because they compute the same function of
the same date.

Play today's puzzle in the browser: https://solsticio.app/
Free Android app: https://play.google.com/store/apps/details?id=es.cs.solsticio

Happy to go deeper on the solver or the uniqueness check if anyone's interested.