Advance M7 workflows and release operations

tools/web/check-engine-variant-install.mjs

@@ -0,0 +1,109 @@
+import assert from "node:assert/strict";
+import crypto from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const installer = path.join(repoRoot, "tools/web/install-web-engine-assets.sh");
+const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "engine-variant-install-test-"));
+
+function sha256(bytes) {
+  return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+function writeBuild(directory, label, includeWasm = true) {
+  fs.mkdirSync(directory, { recursive: true });
+  fs.writeFileSync(path.join(directory, "web_engine.js"), `export default ${JSON.stringify(label)};\n`);
+  if (includeWasm) fs.writeFileSync(path.join(directory, "web_engine.wasm"), Buffer.from(`wasm:${label}`));
+}
+
+function writeLegacyManifest(publicRoot) {
+  fs.mkdirSync(publicRoot, { recursive: true });
+  const manifestPath = path.join(publicRoot, "engine-manifest.json");
+  fs.writeFileSync(manifestPath, `${JSON.stringify({
+    schemaVersion: 1,
+    protocolVersion: 1,
+    engineVersion: "blender-wasm-install-test",
+    engine: "blender-wasm",
+    memory: { initialPages: 256, maximumPages: 32768, shared: false },
+    wasm: [],
+  }, null, 2)}\n`);
+  return manifestPath;
+}
+
+function runInstaller(singleBuild, pthreadBuild, publicRoot) {
+  return spawnSync("bash", [installer], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    env: {
+      ...process.env,
+      WEB_ENGINE_SINGLE_BUILD_DIR: singleBuild,
+      WEB_ENGINE_PTHREAD_BUILD_DIR: pthreadBuild,
+      WEB_ENGINE_PUBLIC_ROOT: publicRoot,
+    },
+  });
+}
+
+try {
+  const positive = path.join(workspace, "positive");
+  const singleBuild = path.join(positive, "build-single");
+  const pthreadBuild = path.join(positive, "build-pthread");
+  const publicRoot = path.join(positive, "public");
+  writeBuild(singleBuild, "single-output");
+  writeBuild(pthreadBuild, "pthread-output");
+  writeLegacyManifest(publicRoot);
+  fs.mkdirSync(path.join(publicRoot, "vendor/blender"), { recursive: true });
+  fs.writeFileSync(path.join(publicRoot, "vendor/blender/web_engine.js"), "legacy-loader\n");
+
+  const installed = runInstaller(singleBuild, pthreadBuild, publicRoot);
+  assert.equal(installed.status, 0, installed.stderr || installed.stdout);
+  const manifest = JSON.parse(fs.readFileSync(path.join(publicRoot, "engine-manifest.json"), "utf8"));
+  assert.equal(manifest.schemaVersion, 2);
+  assert.equal(manifest.releaseId, "blender-wasm-install-test");
+  assert.deepEqual(manifest.variants.map((variant) => variant.id), ["single", "pthread"]);
+  for (const [index, buildDirectory] of [[0, singleBuild], [1, pthreadBuild]]) {
+    const variant = manifest.variants[index];
+    for (const role of ["js", "wasm"]) {
+      const resource = variant.resources[role];
+      const source = fs.readFileSync(path.join(buildDirectory, resource.fileName));
+      const target = fs.readFileSync(path.join(publicRoot, resource.url));
+      assert.deepEqual(target, source);
+      assert.equal(resource.sha256, sha256(source));
+    }
+  }
+  assert.equal(fs.readFileSync(path.join(publicRoot, "vendor/blender/web_engine.js"), "utf8"), "legacy-loader\n");
+  assert.deepEqual(manifest.variants[1].resources.pthreadWorker, manifest.variants[1].resources.js);
+
+  const sameBuildRoot = path.join(workspace, "same-build-negative");
+  const sameBuild = path.join(sameBuildRoot, "build");
+  const samePublic = path.join(sameBuildRoot, "public");
+  writeBuild(sameBuild, "same-output");
+  const sameManifest = writeLegacyManifest(samePublic);
+  const beforeSame = fs.readFileSync(sameManifest);
+  const sameResult = runInstaller(sameBuild, sameBuild, samePublic);
+  assert.notEqual(sameResult.status, 0);
+  assert.match(sameResult.stderr, /independent build directories/);
+  assert.deepEqual(fs.readFileSync(sameManifest), beforeSame);
+  assert.equal(fs.existsSync(path.join(samePublic, "vendor/blender/single")), false);
+
+  const missingRoot = path.join(workspace, "missing-asset-negative");
+  const completeBuild = path.join(missingRoot, "build-single");
+  const incompleteBuild = path.join(missingRoot, "build-pthread");
+  const missingPublic = path.join(missingRoot, "public");
+  writeBuild(completeBuild, "complete-output");
+  writeBuild(incompleteBuild, "incomplete-output", false);
+  const missingManifest = writeLegacyManifest(missingPublic);
+  const beforeMissing = fs.readFileSync(missingManifest);
+  const missingResult = runInstaller(completeBuild, incompleteBuild, missingPublic);
+  assert.notEqual(missingResult.status, 0);
+  assert.deepEqual(fs.readFileSync(missingManifest), beforeMissing);
+  assert.equal(fs.existsSync(path.join(missingPublic, "vendor/blender/single")), false);
+
+  process.stdout.write("engine-variant-install-ok variants=2 negativeCases=2\n");
+}
+finally {
+  fs.rmSync(workspace, { recursive: true, force: true });
+}