Datasets:

introspector
/

retro-sync

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>retro-sync — 71-Shard NFT</title>
<style>
*{box-sizing:border-box;margin:0;padding:0}
body{font-family:monospace;background:#0a0a0a;color:#0f0;padding:1em;max-width:960px;margin:0 auto}
h1{color:#0ff;font-size:1.3em;margin-bottom:.2em}
h2{color:#0ff;font-size:.95em;margin:1em 0 .3em;border-bottom:1px solid #333;padding-bottom:.2em}
textarea,input[type=text]{width:100%;background:#111;color:#0f0;border:1px solid #333;padding:.4em;font-family:monospace;font-size:.85em;resize:vertical}
textarea{height:4em}
button{background:#222;color:#0ff;border:1px solid #0ff;padding:.3em .7em;cursor:pointer;font-family:monospace;font-size:.8em;margin:.2em .2em .2em 0}
button:hover{background:#0ff;color:#000}
.row{display:flex;gap:.4em;flex-wrap:wrap;margin:.3em 0;align-items:center}
.out{background:#111;border:1px solid #333;padding:.4em;margin:.3em 0;word-break:break-all;min-height:1.5em;font-size:.8em;max-height:200px;overflow:auto}
.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(70px,1fr));gap:3px;margin:.5em 0}
.tile{border:1px solid #333;text-align:center;font-size:9px;padding:2px;cursor:pointer;position:relative;min-height:70px}
.tile img{width:100%;image-rendering:pixelated;image-rendering:crisp-edges}
.tile.found{border-color:#0f0;background:#0f01}
.tile.prime{border-color:#ff0}
.tile.prime.found{border-color:#0f0}
.tile:hover{background:#0ff1}
.tile img{width:100%;display:block;image-rendering:pixelated}
.tile .lbl{color:#888}
.status{color:#888;font-size:.8em}
canvas{border:1px solid #333;margin:.3em 0;max-width:100%}
audio{width:100%;margin:.3em 0}
.cid{color:#ff0;font-size:.8em}
</style>
</head>
<body>
<h1>retro-sync — 71-Shard NFT</h1>
<p class="status">6-layer stego · WASM decoder · Groth16/BN254 · Cl(15,0,0)
  <span id="progress" style="color:#0ff">0/71</span>
  <span id="wasm-status" style="color:#f00">⏳ loading WASM…</span>
</p>

<h2>📡 Load Shards</h2>
<textarea id="urls" placeholder="Paste image URLs (one per line), or a base URL like:
https://example.com/retro-sync
(will auto-append /tiles/01.png ... /tiles/71.png and /shards/01.json ... /shards/71.json)"></textarea>
<div class="row">
  <button onclick="loadFromURLs()">⬇ Fetch URLs</button>
  <button onclick="loadFromFile()">📂 Load Image</button>
  <input type="file" id="file-input" accept="image/*" multiple style="display:none">
  <button onclick="loadFromPaste()">📋 Paste Image</button>
  <button onclick="loadPreset('local')">📍 Local</button>
  <button onclick="loadPreset('space')">HF Space</button>
  <button onclick="loadPreset('dataset')">HF Dataset</button>
  <button onclick="loadPreset('archive')">Archive.org</button>
  <button onclick="loadPreset('gh')">GitHub Pages</button>
</div>
<div class="out" id="log"></div>

<h2>🧩 Collection</h2>
<div class="grid" id="grid"></div>

<h2>🔍 Decode</h2>
<div class="row">
  <button onclick="decodeSelected()">Decode Selected</button>
  <button onclick="decodeAll()">Decode All Collected</button>
  <button onclick="reconstruct()">🎵 Reconstruct WAV</button>
  <button onclick="shareLog()">📋 Share Log</button>
</div>
<canvas id="canvas" width="512" height="512"></canvas>
<div class="out" id="decode-out"></div>

<h2>🎵 Player</h2>
<div id="player"></div>

<h2>📦 Shard Data</h2>
<div class="out" id="shard-out" style="white-space:pre-wrap"></div>

<script type="module">
import init, { decode_tile, reconstruct_payload, extract_segment } from './pkg/stego.js';

let wasmReady = false;
init().then(() => {
  wasmReady = true;
  document.getElementById('wasm-status').textContent = '✅ WASM ready';
  document.getElementById('wasm-status').style.color = '#0f0';
  log('🔧 stego WASM loaded');
}).catch(e => {
  document.getElementById('wasm-status').textContent = '❌ WASM failed';
  log('⚠ WASM load failed: ' + e.message);
});

const PRIMES = new Set([2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71]);
const TILE_CAP = 512 * 512 * 6 / 8; // 196608

const tiles = {};
const shardJSON = {};
const tileBytes = {}; // idx → Uint8Array from WASM decode
let selected = null;

const $ = id => document.getElementById(id);
function log(msg) {
  $('log').textContent = msg + '\n' + $('log').textContent.slice(0, 4000);
}
window.log = log;

function shareLog() {
  const text = $('log').textContent + '\n---\n' + $('decode-out').textContent;
  navigator.clipboard.writeText(text).then(() => log('📋 Log copied to clipboard'));
}
window.shareLog = shareLog;

const PRESETS = {
  local:   location.origin + location.pathname.replace(/\/[^/]*$/, ''),
  space:   'https://huggingface.co/spaces/introspector/retro-sync/resolve/main',
  dataset: 'https://huggingface.co/datasets/introspector/retro-sync/resolve/main',
  archive: 'https://archive.org/download/retro-sync',
  gh:      'https://meta-introspector.github.io/retro-sync',
};

function loadPreset(key) { $('urls').value = PRESETS[key] || ''; loadFromURLs(); }
window.loadPreset = loadPreset;

function initFromParams() {
  const p = new URLSearchParams(location.search);
  const base = p.get('base') || p.get('src') || p.get('url');
  const dataset = p.get('dataset');
  const rdfa = p.get('rdfa');
  
  if (base) { $('urls').value = base; loadFromURLs(); return true; }
  
  // HF dataset: ?dataset=user/repo or ?dataset=user/repo/path
  if (dataset) {
    const parts = dataset.split('/');
    const repo = parts.slice(0, 2).join('/');
    const path = parts.slice(2).join('/') || '';
    const hfBase = `https://huggingface.co/datasets/${repo}/resolve/main/${path}`;
    $('urls').value = hfBase;
    log(`📦 Loading HF dataset: ${dataset}`);
    loadFromURLs();
    return true;
  }
  
  // eRDFa shard URL: ?rdfa=https://example.com/shard.cbor
  if (rdfa) {
    log(`🔗 Loading eRDFa shard: ${rdfa}`);
    fetch(rdfa).then(r => r.arrayBuffer()).then(buf => {
      log(`📋 eRDFa shard: ${buf.byteLength} bytes`);
      // Try to extract base URL from shard metadata
      const text = new TextDecoder().decode(new Uint8Array(buf).slice(0, 200));
      const m = text.match(/https?:\/\/[^\s"]+/);
      if (m) { $('urls').value = m[0]; loadFromURLs(); }
    }).catch(e => log(`⚠ eRDFa load failed: ${e.message}`));
    return true;
  }
  
  return false;
}

async function loadFromURLs() {
  let text = $('urls').value.trim();
  if (!text) {
    // Auto-detect: try local path first
    text = window.location.origin + window.location.pathname.replace(/\/[^/]*$/, '');
    $('urls').value = text;
    log('Auto-detecting local tiles...');
  }
  const lines = text.split('\n').map(l => l.trim()).filter(Boolean);

  if (lines.length === 1 && !lines[0].match(/\.(png|jpg|json)$/i)) {
    const base = lines[0].replace(/\/+$/, '');
    log(`Base URL: ${base} — fetching 71 tiles...`);
    let loaded = 0;
    let failed = 0;
    for (let i = 1; i <= 71; i++) {
      const pad = String(i).padStart(2, '0');
      const tileUrl = `${base}/tiles/${pad}.png`;
      if (i === 1) log(`First tile: ${tileUrl}`);
      loadTileFromURL(tileUrl, i);
      fetchShard(`${base}/nft71/${pad}.json`, i).then(() => {
        loaded++; $('progress').textContent = `${loaded}/71`;
      }).catch(() => {});
    }
    return;
  }

  for (const url of lines) {
    const m = url.match(/(\d{1,2})\.(png|jpg|jpeg|json)/i);
    if (m) {
      const idx = parseInt(m[1]);
      if (m[2] === 'json') fetchShard(url, idx);
      else loadTileFromURL(url, idx);
    } else { log(`⚠ Can't parse index from: ${url}`); }
  }
}
window.loadFromURLs = loadFromURLs;

function loadTileFromURL(url, idx) {
  const img = new Image();
  img.crossOrigin = 'anonymous';
  img.onload = () => { tiles[idx] = {img, pixels: null, url}; log(`✅ tile ${idx}`); renderGrid(); };
  img.onerror = () => log(`⚠ tile ${idx} failed: ${url}`);
  img.src = url;
}

async function fetchShard(url, idx) {
  try { const r = await fetch(url); if (r.ok) shardJSON[idx] = await r.json(); } catch(e) {}
}

$('file-input').onchange = e => {
  for (const file of e.target.files) {
    const m = file.name.match(/(\d{1,2})/);
    const idx = m ? parseInt(m[1]) : Object.keys(tiles).length + 1;
    const img = new Image();
    img.onload = () => { tiles[idx] = {img, pixels: null, url: file.name}; log(`✅ loaded ${file.name} as tile ${idx}`); renderGrid(); };
    img.src = URL.createObjectURL(file);
  }
};
function loadFromFile() { $('file-input').click(); }
window.loadFromFile = loadFromFile;

async function loadFromPaste() {
  try {
    const items = await navigator.clipboard.read();
    for (const item of items) {
      for (const type of item.types) {
        if (type.startsWith('image/')) {
          const blob = await item.getType(type);
          const idx = Object.keys(tiles).length + 1;
          const img = new Image();
          img.onload = () => { tiles[idx] = {img, pixels: null, url: 'clipboard'}; log(`✅ pasted as tile ${idx}`); renderGrid(); };
          img.src = URL.createObjectURL(blob);
          return;
        }
      }
    }
    log('⚠ No image in clipboard');
  } catch(e) { log('⚠ Clipboard: ' + e.message); }
}
window.loadFromPaste = loadFromPaste;

function renderGrid() {
  let html = '';
  for (let i = 1; i <= 71; i++) {
    const t = tiles[i];
    const prime = PRIMES.has(i);
    const cls = [t ? 'found' : '', prime ? 'prime' : ''].join(' ');
    const sel = selected === i ? 'outline:2px solid #0ff;' : '';
    if (t) {
      html += `<div class="tile ${cls}" style="${sel}" onclick="selectTile(${i})">
        <img src="${t.img.src}"><div class="lbl">${prime?'★':'·'}${i}</div></div>`;
    } else {
      html += `<div class="tile ${cls}" style="${sel}" onclick="selectTile(${i})">
        <div style="padding:15px 0">${prime?'★':'·'}${i}</div><div class="lbl">—</div></div>`;
    }
  }
  $('grid').innerHTML = html;
}

function getPixels(idx) {
  const t = tiles[idx];
  if (!t) return null;
  if (t.pixels) return t.pixels;
  const c = document.createElement('canvas');
  c.width = t.img.width; c.height = t.img.height;
  c.getContext('2d').drawImage(t.img, 0, 0);
  t.pixels = c.getContext('2d').getImageData(0, 0, c.width, c.height).data;
  return t.pixels;
}

function selectTile(idx) {
  selected = idx;
  renderGrid();
  const t = tiles[idx];
  if (t) {
    const canvas = $('canvas');
    canvas.width = t.img.width; canvas.height = t.img.height;
    canvas.getContext('2d').drawImage(t.img, 0, 0);
  }
  if (shardJSON[idx]) {
    $('shard-out').textContent = JSON.stringify(shardJSON[idx], null, 2).slice(0, 3000);
  } else {
    $('shard-out').textContent = `Shard ${idx} — no JSON loaded`;
  }
}
window.selectTile = selectTile;

function decodeSelected() {
  if (!wasmReady) { log('⚠ WASM not loaded yet'); return; }
  if (!selected || !tiles[selected]) { log('Select a tile first'); return; }
  const rgba = getPixels(selected);
  if (!rgba) return;

  const bytes = decode_tile(new Uint8Array(rgba));
  tileBytes[selected] = bytes;

  const nonZero = bytes.filter(b => b !== 0).length;
  const hex = Array.from(bytes.slice(0, 32)).map(b => b.toString(16).padStart(2, '0')).join(' ');
  const magic = String.fromCharCode(bytes[0], bytes[1], bytes[2], bytes[3]);
  $('decode-out').textContent = `Tile ${selected} — ${bytes.length}B extracted (${nonZero} non-zero)\nFirst 4: "${magic}"\nHex: ${hex}…`;
  log(`✅ decoded tile ${selected}: ${nonZero} non-zero bytes`);
}
window.decodeSelected = decodeSelected;

function decodeAll() {
  if (!wasmReady) { log('⚠ WASM not loaded yet'); return; }
  let count = 0;
  for (let i = 1; i <= 71; i++) {
    if (!tiles[i]) continue;
    const rgba = getPixels(i);
    if (!rgba) continue;
    tileBytes[i] = decode_tile(new Uint8Array(rgba));
    count++;
  }
  log(`✅ decoded ${count} tiles via WASM`);
  $('decode-out').textContent = `${count} tiles decoded. Click "Reconstruct WAV" to assemble.`;
}
window.decodeAll = decodeAll;

function reconstruct() {
  if (!wasmReady) { log('⚠ WASM not loaded yet'); return; }
  const n = Object.keys(tiles).length;
  if (n < 71) log(`⚠ Have ${n}/71 tiles`);

  log('Decoding all tiles via WASM...');
  // Decode any missing tiles
  for (let i = 1; i <= 71; i++) {
    if (tileBytes[i]) continue;
    const rgba = getPixels(i);
    if (rgba) tileBytes[i] = decode_tile(new Uint8Array(rgba));
  }

  // Concatenate all tile bytes in order
  const total = TILE_CAP * 71;
  const allBytes = new Uint8Array(total);
  for (let i = 1; i <= 71; i++) {
    if (tileBytes[i]) allBytes.set(tileBytes[i], (i - 1) * TILE_CAP);
  }

  // Use WASM to parse NFT7
  const info = reconstruct_payload(allBytes);
  const parsed = JSON.parse(info);

  if (parsed.error) {
    log(`⚠ ${parsed.error}`);
    $('decode-out').textContent = `Error: ${parsed.error}\nFirst 32 bytes: ${parsed.first32}`;
    return;
  }

  let out = `🎵 NFT7 decoded — ${parsed.segments.length} segments:\n`;
  for (const s of parsed.segments) out += `  ${s.name}: ${s.size.toLocaleString()} B  sha256:${s.sha256.slice(0,16)}…\n`;
  $('decode-out').textContent = out;
  log(`🎵 ${parsed.segments.length} segments reconstructed`);

  const MIME = {wav:'audio/wav', midi:'audio/midi', pdf:'application/pdf',
    source:'text/plain', lilypond:'text/x-lilypond', data:'text/plain', witnesses:'application/json'};
  const EXT = {wav:'.wav', midi:'.midi', pdf:'.pdf',
    source:'.txt', lilypond:'.ly', data:'.txt', witnesses:'.json'};

  let html = `<p style="color:#0ff">retro-sync — ${parsed.segments.length} files from ${n} tiles</p>`;

  // Parse witnesses for verification
  let witnesses = [];
  try {
    const wData = extract_segment(allBytes, 'witnesses');
    const wText = new TextDecoder().decode(wData);
    // witnesses are concatenated JSON objects — split on }{ boundary
    witnesses = wText.split(/\}\s*\{/).map((s,i,a) =>
      JSON.parse((i>0?'{':'') + s + (i<a.length-1?'}':''))
    );
  } catch(e) {}

  // Show witness chain
  if (witnesses.length) {
    html += `<div style="margin:8px 0;padding:6px;background:#111;border:1px solid #333">`;
    html += `<div style="color:#0ff;margin-bottom:4px">🔗 Witness Chain (${witnesses.length} steps)</div>`;
    for (const w of witnesses) {
      if (w.output_hash) {
        html += `<div style="font-size:.75em;color:#8b949e">`;
        html += `${w.step}: <span style="color:#ff0">${w.output_hash.slice(0,16)}…</span> `;
        html += `${w.output_file||''} ${w.output_bytes?'('+w.output_bytes.toLocaleString()+'B)':''} `;
        html += `<span style="color:#666">${w.tool||''} ${w.tool_version||''}</span></div>`;
      } else if (w.chain_hash) {
        html += `<div style="font-size:.75em;color:#0f0">`;
        html += `${w.step}: commitment <span style="color:#ff0">${w.chain_hash.slice(0,32)}…</span></div>`;
      } else if (w.sha256) {
        html += `<div style="font-size:.75em;color:#8b949e">`;
        html += `${w.step}: source <span style="color:#ff0">${w.sha256.slice(0,16)}…</span> ${w.file||''}</div>`;
      }
    }
    html += `</div>`;
  }

  // Download + preview for each segment
  for (const s of parsed.segments) {
    const data = extract_segment(allBytes, s.name);
    const blob = new Blob([data], {type: MIME[s.name] || 'application/octet-stream'});
    const url = URL.createObjectURL(blob);
    const ext = EXT[s.name] || '.bin';
    const sz = s.size > 1048576 ? (s.size/1048576).toFixed(1)+' MB' : (s.size/1024).toFixed(1)+' KB';
    html += `<div style="margin:4px 0">`;
    html += `<a href="${url}" download="segment${ext}" style="color:#0f0">⬇ ${s.name}${ext}</a> `;
    html += `<span style="color:#888">${sz}</span> `;
    html += `<span style="color:#ff0;font-size:.7em">sha256:${s.sha256.slice(0,16)}…</span>`;
    if (s.name === 'wav') {
      html += `<br><audio controls src="${url}" style="width:100%;margin:2px 0"></audio>`;
    } else if (s.name === 'pdf') {
      html += ` <a href="${url}" target="_blank" style="color:#58a6ff">📄 view</a>`;
    } else if (s.name === 'midi_bundle') {
      // Split bundle into individual MIDIs at MThd boundaries
      const arr = new Uint8Array(data);
      const midis = [];
      for (let j = 0; j < arr.length - 4; j++) {
        if (arr[j]===0x4D && arr[j+1]===0x54 && arr[j+2]===0x68 && arr[j+3]===0x64) midis.push(j);
      }
      html += `<div style="margin:4px 0;color:#0ff">${midis.length} MIDIs in bundle</div>`;
      for (let m = 0; m < midis.length; m++) {
        const start = midis[m];
        const end = m+1 < midis.length ? midis[m+1] : arr.length;
        const midiData = arr.slice(start, end);
        const midiBlob = new Blob([midiData], {type:'audio/midi'});
        const midiUrl = URL.createObjectURL(midiBlob);
        html += `<div style="margin:2px 0">`;
        html += `<a href="${midiUrl}" download="invention_${m+1}.mid" style="color:#0f0">⬇ #${m+1}</a> `;
        html += `<span style="color:#888">${(end-start/1024).toFixed(1)}KB</span> `;
        html += `<button onclick="playMidi(this,'${midiUrl}')" style="font-size:10px">▶ Play</button>`;
        html += `</div>`;
      }
    } else if (s.name === 'midi') {
      html += ` <span style="color:#888">🎹 MIDI</span>`;
    } else if (['source','lilypond','data','witnesses'].includes(s.name)) {
      const text = new TextDecoder().decode(data);
      html += `<pre style="color:#0f0;font-size:.7em;max-height:80px;overflow:auto;margin:2px 0;padding:3px;background:#111;border:1px solid #222">${text.replace(/</g,'&lt;').slice(0,2000)}</pre>`;
    }
    html += `</div>`;
  }
  $('player').innerHTML = html;
}
window.reconstruct = reconstruct;

// MIDI player via Tone.js + @tonejs/midi
let toneLoaded = false;
async function loadTone() {
  if (toneLoaded) return;
  const s1 = document.createElement('script');
  s1.src = 'https://cdn.jsdelivr.net/npm/tone@14/build/Tone.min.js';
  document.head.appendChild(s1);
  const s2 = document.createElement('script');
  s2.src = 'https://cdn.jsdelivr.net/npm/@tonejs/midi@2/build/Midi.js';
  document.head.appendChild(s2);
  await new Promise(r => { s2.onload = r; setTimeout(r, 3000); });
  toneLoaded = true;
}

let currentSynth = null;
async function playMidi(btn, url) {
  await loadTone();
  if (currentSynth) { currentSynth.dispose(); currentSynth = null; btn.textContent = '▶ Play'; }
  btn.textContent = '⏳';
  try {
    const resp = await fetch(url);
    const buf = await resp.arrayBuffer();
    const midi = new Midi(buf);
    await Tone.start();
    const synth = new Tone.PolySynth(Tone.Synth, {maxPolyphony: 16}).toDestination();
    currentSynth = synth;
    const now = Tone.now();
    for (const track of midi.tracks) {
      for (const note of track.notes) {
        synth.triggerAttackRelease(note.name, note.duration, now + note.time, note.velocity);
      }
    }
    btn.textContent = '⏹ Stop';
    btn.onclick = () => { synth.dispose(); currentSynth = null; btn.textContent = '▶ Play'; btn.onclick = () => playMidi(btn, url); };
  } catch(e) { log('⚠ MIDI play error: ' + e.message); btn.textContent = '▶ Play'; }
}
window.playMidi = playMidi;

renderGrid();
log('🚀 Page loaded, checking params...');
if (!initFromParams()) {
  log('📍 No URL params, loading local preset...');
  loadPreset('local');
}
</script>
</body>
</html>