Update Healer Man server

scripts/runewaker-pipeline/lib/native-alpha-cache-validation.mjs

@@ -0,0 +1,98 @@
+const SHA256 = /^[\da-f]{64}$/i;
+const REQUIRED_ALPHA_PARAMETERS = ["alphaTestMode", "alphaMode", "translucent", "alpha", "alphaModifier"];
+
+function normalizeResource(value) {
+  return String(value ?? "").replaceAll("\\", "/").replace(/^\/+/, "").toLowerCase();
+}
+
+function reportErrors(report, label, expectedResource, expectedSourceSha256) {
+  const errors = [];
+  if (!report || typeof report !== "object") return [`${label} report is missing`];
+  if (normalizeResource(report.sourceModel) !== normalizeResource(expectedResource)) {
+    errors.push(`${label} source model does not match the cached resource`);
+  }
+  if (!SHA256.test(String(report.sourceResourceSha256 ?? ""))
+    || report.sourceResourceSha256.toLowerCase() !== expectedSourceSha256.toLowerCase()) {
+    errors.push(`${label} source resource SHA-256 is missing or stale`);
+  }
+  if (!Array.isArray(report.materials) || report.materials.length === 0) {
+    errors.push(`${label} native material rows are missing`);
+    return errors;
+  }
+
+  for (const material of report.materials) {
+    const identity = String(material?.name ?? "");
+    if (!/^runewaker_material_\d+$/i.test(identity)) {
+      errors.push(`${label} has a material row without a native material index`);
+      continue;
+    }
+    if (!Array.isArray(material.sourceTextureChannels)) {
+      errors.push(`${label} ${identity} has no source texture channel inventory`);
+    }
+    const parameters = new Set((material.alphaBlendParameters ?? [])
+      .filter((parameter) => parameter && typeof parameter.name === "string")
+      .map((parameter) => parameter.name));
+    for (const required of REQUIRED_ALPHA_PARAMETERS) {
+      if (!parameters.has(required)) {
+        errors.push(`${label} ${identity} lacks native alpha parameter ${required}`);
+      }
+    }
+    const alphaValues = Object.fromEntries((material.alphaBlendParameters ?? [])
+      .filter(parameter => parameter && typeof parameter.name === "string")
+      .map(parameter => [parameter.name, parameter.value]));
+    if (alphaValues.alphaTestMode === 1
+      && (!Number.isInteger(alphaValues.alphaTestValue) || alphaValues.alphaTestValue < 0 || alphaValues.alphaTestValue > 255)) {
+      errors.push(`${label} ${identity} lacks a valid native alpha-test cutoff`);
+    }
+    if (material.sourceTexture) {
+      const diffuse = (material.sourceTextureChannels ?? [])
+        .filter((channel) => String(channel?.name ?? "").toLowerCase() === "diffuse")
+        .map((channel) => normalizeResource(channel.texture));
+      if (!diffuse.includes(normalizeResource(material.sourceTexture))) {
+        errors.push(`${label} ${identity} diffuse channel does not match its source texture`);
+      }
+    }
+  }
+  return errors;
+}
+
+/** Fail closed when a resource cache predates exact ROS material-alpha provenance. */
+export function validateNativeAlphaResourceCache({
+  manifest,
+  rawReport,
+  preparedReport,
+  expectedResource,
+  expectedSourceSha256,
+  expectedToolchain,
+}) {
+  const errors = [];
+  if (!manifest || typeof manifest !== "object") {
+    errors.push("cache manifest is missing");
+  } else {
+    if (normalizeResource(manifest.source?.resource) !== normalizeResource(expectedResource)) {
+      errors.push("cache manifest source resource does not match");
+    }
+    if (!SHA256.test(String(expectedSourceSha256 ?? ""))
+      || manifest.source?.sha256?.toLowerCase() !== expectedSourceSha256.toLowerCase()) {
+      errors.push("cache manifest source SHA-256 does not match");
+    }
+    for (const name of ["converterSha256", "exporterSha256", "nativeAlphaPolicySha256"]) {
+      const expected = expectedToolchain?.[name];
+      const actual = manifest.toolchain?.[name];
+      if (!SHA256.test(String(expected ?? "")) || actual?.toLowerCase() !== expected.toLowerCase()) {
+        errors.push(`cache toolchain ${name} is missing or stale`);
+      }
+    }
+  }
+  errors.push(...reportErrors(rawReport, "raw", expectedResource, expectedSourceSha256));
+  errors.push(...reportErrors(preparedReport, "prepared", expectedResource, expectedSourceSha256));
+  if (rawReport && preparedReport
+    && JSON.stringify(rawReport.materials) !== JSON.stringify(preparedReport.materials)) {
+    errors.push("prepared material rows differ from the raw native exporter report");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    nativeMaterialCount: Array.isArray(rawReport?.materials) ? rawReport.materials.length : 0,
+  };
+}