@supersoniks/concorde 4.9.95 → 4.9.97-visual-stack.0

package/scripts/build-addons.mjs

@@ -0,0 +1,26 @@
+/**
+ * Construit les bundles CDN opt-in (3d, shader, webgpu, hugging-face-infer).
+ * À lancer après le build core (`emptyOutDir: false` pour ne pas l’écraser).
+ */
+
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const addons = ["3d", "shader", "webgpu", "hugging-face-infer"];
+
+for (const addon of addons) {
+
+  console.log(`📦 Addon CDN : ${addon}`);
+
+  execSync(`vite build`, {
+
+    cwd: root,
+    stdio: "inherit",
+    env: { ...process.env, LIB_NAME: "addon", ADDON: addon },
+  });
+
+}
+
+console.log("✅ Bundles addons CDN générés");

package/scripts/gen-shader-depth.mjs

@@ -0,0 +1,85 @@
+import { pipeline } from "@huggingface/transformers";
+import { writeFileSync } from "fs";
+import { deflateSync } from "zlib";
+
+const imgPath = "public/docs/shader-samples/color.jpg";
+const outPath = "public/docs/shader-samples/depth.png";
+
+console.log("Loading depth pipeline…");
+const depth = await pipeline(
+  "depth-estimation",
+  "Xenova/depth-anything-small-hf",
+);
+console.log("Running on", imgPath);
+const out = await depth(imgPath);
+const d = out.depth ?? out;
+console.log("depth", d?.constructor?.name, d?.width, d?.height, d?.channels);
+
+if (typeof d?.save === "function") {
+  await d.save(outPath);
+  console.log("saved via RawImage.save →", outPath);
+  process.exit(0);
+}
+
+const w = d.width;
+const h = d.height;
+const src = d.data;
+let min = Infinity;
+let max = -Infinity;
+for (let i = 0; i < src.length; i++) {
+  const v = Number(src[i]);
+  if (v < min) min = v;
+  if (v > max) max = v;
+}
+const range = max - min || 1;
+console.log("min/max", min, max);
+
+// RGB PNG (grayscale repeated)
+const stride = w * 3 + 1;
+const raw = Buffer.alloc(stride * h);
+for (let y = 0; y < h; y++) {
+  raw[y * stride] = 0;
+  for (let x = 0; x < w; x++) {
+    const v = Math.round(((Number(src[y * w + x]) - min) / range) * 255);
+    const o = y * stride + 1 + x * 3;
+    raw[o] = raw[o + 1] = raw[o + 2] = v;
+  }
+}
+
+function crc32(buf) {
+  let c = ~0;
+  for (let i = 0; i < buf.length; i++) {
+    c ^= buf[i];
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? (0xedb88320 ^ (c >>> 1)) : c >>> 1;
+    }
+  }
+  return ~c >>> 0;
+}
+
+function chunk(type, data) {
+  const typeB = Buffer.from(type);
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length);
+  const crcB = Buffer.alloc(4);
+  crcB.writeUInt32BE(crc32(Buffer.concat([typeB, data])));
+  return Buffer.concat([len, typeB, data, crcB]);
+}
+
+const ihdr = Buffer.alloc(13);
+ihdr.writeUInt32BE(w, 0);
+ihdr.writeUInt32BE(h, 4);
+ihdr[8] = 8;
+ihdr[9] = 2; // RGB
+ihdr[10] = 0;
+ihdr[11] = 0;
+ihdr[12] = 0;
+
+const png = Buffer.concat([
+  Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]),
+  chunk("IHDR", ihdr),
+  chunk("IDAT", deflateSync(raw, { level: 9 })),
+  chunk("IEND", Buffer.alloc(0)),
+]);
+writeFileSync(outPath, png);
+console.log("saved PNG", outPath, png.length, `${w}x${h}`);

package/scripts/gen-shader-harris-video.mjs

@@ -0,0 +1,17 @@
+/**
+ * Rebuild public/docs/shader-samples/video.webm — vraie façade (Wikimedia),
+ * coins distincts pour démos Harris / extract.
+ *
+ *   python3 -m venv /tmp/venv-vid && . /tmp/venv-vid/bin/activate
+ *   pip install imageio-ffmpeg
+ *   node scripts/gen-shader-harris-video.mjs
+ *   # ou : python3 scripts/gen-shader-harris-video.py
+ */
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const py = path.join(root, "scripts/gen-shader-harris-video.py");
+const r = spawnSync("python3", [py], { stdio: "inherit", cwd: root });
+process.exit(r.status ?? 1);

package/scripts/gen-shader-harris-video.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""
+Rebuild public/docs/shader-samples/video.webm from a real Wikimedia facade clip
+(distinct architectural corners for Harris / extract demos).
+
+Source (CC BY-SA): Exterior del Centro Municipal de las Artes, Mazatlán
+https://commons.wikimedia.org/wiki/File:Exterior_del_Centro_Municipal_de_las_Artes,_Mazatl%C3%A1n,_14_de_agosto_de_2023.webm
+
+Prérequis : pip install imageio-ffmpeg
+  python3 scripts/gen-shader-harris-video.py
+  # ou : node scripts/gen-shader-harris-video.mjs
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+OUT = ROOT / "public/docs/shader-samples/video.webm"
+
+SRC_URL = (
+    "https://upload.wikimedia.org/wikipedia/commons/8/85/"
+    "Exterior_del_Centro_Municipal_de_las_Artes%2C_Mazatl%C3%A1n%2C_"
+    "14_de_agosto_de_2023.webm"
+)
+UA = "ConcordeDocsBot/1.0 (shader sample rebuild; local)"
+
+
+def ffmpeg_bin() -> str:
+    try:
+        import imageio_ffmpeg
+
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    except Exception as e:  # noqa: BLE001
+        raise SystemExit(
+            "imageio-ffmpeg requis : pip install imageio-ffmpeg"
+        ) from e
+
+
+def main() -> None:
+    ff = ffmpeg_bin()
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(prefix="harris-vid-") as tmp:
+        src = Path(tmp) / "src.webm"
+        req = urllib.request.Request(SRC_URL, headers={"User-Agent": UA})
+        print(f"download {SRC_URL}")
+        with urllib.request.urlopen(req, timeout=120) as r, open(src, "wb") as f:
+            f.write(r.read())
+        # Plan façade ~7s, léger deshake + ralenti 1.8× → patches plus stables
+        cmd = [
+            ff,
+            "-y",
+            "-ss",
+            "0.3",
+            "-t",
+            "7",
+            "-i",
+            str(src),
+            "-vf",
+            "deshake,scale=640:360:flags=lanczos,setpts=1.8*PTS,fps=24",
+            "-an",
+            "-c:v",
+            "libvpx-vp9",
+            "-b:v",
+            "700k",
+            "-row-mt",
+            "1",
+            "-deadline",
+            "good",
+            "-cpu-used",
+            "2",
+            str(OUT),
+        ]
+        print(" ".join(cmd))
+        subprocess.check_call(cmd)
+    print(f"wrote {OUT} ({os.path.getsize(OUT)} bytes)")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/hf-vendor.mjs

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+/**
+ * Prépare les fichiers à héberger sur le CDN pour `sonic-hugging-face-infer`.
+ *
+ *   # Moteur figé (Transformers.js + binaires ONNX Runtime de la MÊME version)
+ *   node scripts/hf-vendor.mjs runtime --out ./cdn/vendor/hf-transformers
+ *     → ./cdn/vendor/hf-transformers/<version>/{transformers.min.js, ort-wasm-simd-threaded*.{mjs,wasm}, manifest.json}
+ *
+ *   # Un modèle, à une révision figée (réseau vers huggingface.co requis)
+ *   node scripts/hf-vendor.mjs model Xenova/paraphrase-multilingual-MiniLM-L12-v2 <sha> --dtype q8 --out ./cdn/models
+ *     → ./cdn/models/<repo>/<sha>/…   (à servir avec remotePathTemplate: "{model}/{revision}/")
+ *
+ * Servir ces dossiers avec `Cache-Control: public, max-age=31536000, immutable`
+ * (les chemins contiennent la version / la révision : ils ne changent jamais).
+ */
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const require = createRequire(import.meta.url);
+const [, , command, ...rest] = process.argv;
+
+function option(name, fallback) {
+  const i = rest.indexOf(`--${name}`);
+  return i >= 0 && rest[i + 1] ? rest[i + 1] : fallback;
+}
+
+function sha256(file) {
+  return createHash("sha256").update(readFileSync(file)).digest("hex");
+}
+
+/** Dossier d'un paquet installé (sans passer par ses `exports`). */
+function packageDir(name, from = process.cwd()) {
+  const candidates = require.resolve.paths(name) ?? [];
+  for (const dir of [path.join(from, "node_modules"), ...candidates]) {
+    if (existsSync(path.join(dir, name, "package.json"))) return path.join(dir, name);
+  }
+  throw new Error(`Paquet introuvable : ${name} (npm i -D ${name}).`);
+}
+
+function runtime() {
+  const out = path.resolve(option("out", "./cdn/vendor/hf-transformers"));
+  const tfDir = packageDir("@huggingface/transformers");
+  const tf = JSON.parse(readFileSync(path.join(tfDir, "package.json"), "utf8"));
+  // onnxruntime-web imbriqué sous Transformers.js s'il existe, sinon à la racine.
+  const nested = path.join(tfDir, "node_modules/onnxruntime-web");
+  const ortDir = existsSync(path.join(nested, "package.json"))
+    ? nested
+    : packageDir("onnxruntime-web");
+  const ort = JSON.parse(readFileSync(path.join(ortDir, "package.json"), "utf8"));
+  if (ort.version !== tf.dependencies["onnxruntime-web"]) {
+    console.error(
+      `onnxruntime-web ${ort.version} ≠ version attendue par Transformers.js (${tf.dependencies["onnxruntime-web"]}).`,
+    );
+    process.exit(1);
+  }
+  const target = path.join(out, tf.version);
+  mkdirSync(target, { recursive: true });
+  const files = [
+    [path.join(tfDir, "dist/transformers.min.js"), "transformers.min.js"],
+    // Build WebGPU (asyncify), utilisé partout sauf Safari < 26 sans WebGPU.
+    [path.join(ortDir, "dist/ort-wasm-simd-threaded.asyncify.mjs"), "ort-wasm-simd-threaded.asyncify.mjs"],
+    [path.join(ortDir, "dist/ort-wasm-simd-threaded.asyncify.wasm"), "ort-wasm-simd-threaded.asyncify.wasm"],
+    [path.join(ortDir, "dist/ort-wasm-simd-threaded.mjs"), "ort-wasm-simd-threaded.mjs"],
+    [path.join(ortDir, "dist/ort-wasm-simd-threaded.wasm"), "ort-wasm-simd-threaded.wasm"],
+  ];
+  const manifest = {
+    transformers: tf.version,
+    "onnxruntime-web": ort.version,
+    generatedAt: new Date().toISOString(),
+    files: {},
+  };
+  for (const [from, name] of files) {
+    copyFileSync(from, path.join(target, name));
+    manifest.files[name] = sha256(from);
+  }
+  writeFileSync(path.join(target, "manifest.json"), JSON.stringify(manifest, null, 2));
+  console.log(`✅ Moteur ${tf.version} (onnxruntime-web ${ort.version}) → ${target}`);
+  console.log(`   runtime: { source: "cdn", version: "${tf.version}", url: "<cdn>/${tf.version}/transformers.min.js" }`);
+}
+
+const DTYPE_SUFFIX = {
+  fp32: "",
+  fp16: "_fp16",
+  q8: "_quantized",
+  int8: "_int8",
+  uint8: "_uint8",
+  q4: "_q4",
+  q4f16: "_q4f16",
+  bnb4: "_bnb4",
+};
+
+async function model() {
+  const [repo, revision] = rest;
+  if (!repo || !revision || repo.startsWith("--") || revision.startsWith("--")) {
+    console.error("Usage : node scripts/hf-vendor.mjs model <repo> <révision (sha)> [--dtype q8] [--out ./cdn/models]");
+    process.exit(1);
+  }
+  if (!/^[0-9a-f]{40}$/.test(revision)) {
+    console.warn(`⚠️  « ${revision} » n'est pas un sha de commit : la révision peut bouger.`);
+  }
+  const dtype = option("dtype", "q8");
+  const suffix = DTYPE_SUFFIX[dtype];
+  if (suffix === undefined) {
+    console.error(`dtype inconnu : ${dtype} (${Object.keys(DTYPE_SUFFIX).join(", ")})`);
+    process.exit(1);
+  }
+  const hub = option("hub", "https://huggingface.co");
+  const out = path.resolve(option("out", "./cdn/models"), repo, revision);
+  const info = await fetch(`${hub}/api/models/${repo}/revision/${revision}`).then((r) => {
+    if (!r.ok) throw new Error(`API Hub ${r.status}`);
+    return r.json();
+  });
+  const names = info.siblings.map((s) => s.rfilename);
+  const wanted = names.filter(
+    (f) =>
+      /^(config|generation_config|preprocessor_config|tokenizer|tokenizer_config|special_tokens_map|vocab|merges|sentencepiece\.bpe|source|target)\.(json|txt|model)$/.test(f) ||
+      new RegExp(`^onnx/[a-z_]*model${suffix}\\.onnx(_data(_\\d+)?)?$`).test(f),
+  );
+  if (!wanted.some((f) => f.endsWith(".onnx"))) {
+    console.error(`Aucun fichier ONNX « *${suffix}.onnx » pour ${repo}@${revision}.`);
+    process.exit(1);
+  }
+  const manifest = { repo, revision, dtype, license: info.cardData?.license ?? null, files: {} };
+  let total = 0;
+  for (const file of wanted) {
+    const dest = path.join(out, file);
+    mkdirSync(path.dirname(dest), { recursive: true });
+    if (!existsSync(dest)) {
+      const res = await fetch(`${hub}/${repo}/resolve/${revision}/${file}`);
+      if (!res.ok) throw new Error(`${file} : ${res.status}`);
+      writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+    }
+    const size = readFileSync(dest).length;
+    total += size;
+    manifest.files[file] = { size, sha256: sha256(dest) };
+    console.log(`   ${file} (${(size / 1048576).toFixed(1)} Mo)`);
+  }
+  writeFileSync(path.join(out, "manifest.json"), JSON.stringify(manifest, null, 2));
+  console.log(`✅ ${repo}@${revision} (${dtype}) → ${out} — ${(total / 1048576).toFixed(1)} Mo`);
+  console.log(`   Licence : ${manifest.license ?? "à vérifier"} — sizeBytes: ${total}`);
+}
+
+if (command === "runtime") runtime();
+else if (command === "model")
+  await model().catch((err) => {
+    console.error(`❌ ${err.message}${err.cause ? ` (${err.cause.message ?? err.cause})` : ""}`);
+    process.exit(1);
+  });
+else {
+  console.log("Usage : node scripts/hf-vendor.mjs runtime|model …  (voir l'en-tête du script)");
+  process.exit(command ? 1 : 0);
+}

package/scripts/post-build.mjs

@@ -1,14 +1,120 @@
-// console.log("hey");
-
 import fs from "fs";
 import path from "path";
+import { execSync } from "child_process";
+import { fileURLToPath } from "url";
 
-//copy concorde-core.bundle.js and concorde-core.es.js from docs to the root of the project
-fs.copyFileSync(
-  path.resolve("dist/concorde-core.bundle.js"),
-  path.resolve("concorde-core.bundle.js")
-);
-fs.copyFileSync(
-  path.resolve("dist/concorde-core.es.js"),
-  path.resolve("concorde-core.es.js")
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, "..");
+
+const rootBundles = [
+
+  {
+
+    stem: "concorde-core",
+    checks: [
+      ["concordeIsLoaded", "signal de chargement"],
+      ["customElements.define", "enregistrement des web components"],
+      ["concorde-loaded", "événement concorde-loaded"],
+    ],
+  },
+
+  {
+
+    stem: "concorde-3d",
+    checks: [
+      ["sonic-3d", "tag sonic-3d"],
+      ["customElements", "enregistrement custom element"],
+    ],
+  },
+
+  {
+
+    stem: "concorde-shader",
+    checks: [
+      ["sonic-shader", "tag sonic-shader"],
+      ["customElements", "enregistrement custom element"],
+    ],
+  },
+
+  {
+
+    stem: "concorde-webgpu",
+    checks: [
+      ["sonic-webgpu", "tag sonic-webgpu"],
+      ["customElements", "enregistrement custom element"],
+    ],
+  },
+
+  {
+
+    stem: "concorde-hugging-face-infer",
+    checks: [
+      ["sonic-hugging-face-infer", "tag sonic-hugging-face-infer"],
+      ["configureHuggingFace", "API configureHuggingFace"],
+    ],
+  },
+];
+
+for (const { stem, checks } of rootBundles) {
+
+  for (const ext of ["bundle.js", "es.js"]) {
+
+    const file = `${stem}.${ext}`;
+    const from = path.resolve("dist", file);
+    const to = path.resolve(file);
+
+    if (!fs.existsSync(from)) {
+
+      console.error(`❌ Bundle manquant : ${from}`);
+      process.exit(1);
+
+    }
+
+    fs.copyFileSync(from, to);
+    const content = fs.readFileSync(to, "utf8");
+
+    for (const [needle, label] of checks) {
+
+      if (!content.includes(needle)) {
+
+        console.error(`❌ ${file} : marqueur manquant (${label})`);
+        process.exit(1);
+
+      }
+
+    }
+
+  }
+
+}
+
+console.log("✅ Bundles core + addons CDN vérifiés");
+
+console.log("🚀 Génération des types (.d.ts)");
+const fetcherPath = path.join(root, "src/core/mixins/Fetcher.ts");
+const fetcherOriginal = fs.readFileSync(fetcherPath, "utf8");
+fs.writeFileSync(
+  fetcherPath,
+  fetcherOriginal.replace("protected async _fetchData()", "async _fetchData()")
 );
+
+try {
+
+  execSync("tsc -p src/tsconfig.declarations.json", {
+
+    cwd: root,
+    stdio: "inherit",
+  });
+} finally {
+
+  fs.writeFileSync(fetcherPath, fetcherOriginal);
+
+}
+
+console.log("🚀 Génération du JavaScript (dist/js/)");
+
+execSync("tsc -p src/tsconfig.emit.json", {
+
+  cwd: root,
+  stdio: "inherit",
+});