João Henrique
b541f502ba
- Adicionado estrutura completa do projeto - Configurado MCP server para Premiere Pro - Adicionado documentação e skills - Configurado Gitignore para o projeto
321 lines
16 KiB
JavaScript
Executable File
321 lines
16 KiB
JavaScript
Executable File
import { readFile } from "node:fs/promises";
|
|
import { pathToFileURL } from "node:url";
|
|
import {
|
|
canonicalNativeSdkHeaderInventorySha256,
|
|
verifyNativeSdkHeaderInventory,
|
|
} from "./verify-native-sdk-header-inventory.mjs";
|
|
import {
|
|
canonicalUxpHybridAddonReceiptSha256,
|
|
verifyUxpHybridAddonReceipt,
|
|
} from "./verify-uxp-hybrid-addon-receipt.mjs";
|
|
import {
|
|
buildUxpHybridCcxReceipt,
|
|
canonicalUxpHybridCcxReceiptSha256,
|
|
verifyUxpHybridCcxReceipt,
|
|
} from "./uxp-hybrid-ccx-receipt-core.mjs";
|
|
|
|
export const REQUIRED_TARGETS = ["win-x64", "mac-x64", "mac-arm64"];
|
|
const LOCAL_CCX_ARCHIVE_REQUIRED = "A local CCX archive must be rechecked for schemaVersion 3.";
|
|
|
|
export function verifyHybridBenchmarkEvidence(document, options = {}) {
|
|
const minimumSpeedupPercent = finiteOption(options.minimumSpeedupPercent, 30, "minimumSpeedupPercent");
|
|
const maximumMemoryRegressionPercent = finiteOption(options.maximumMemoryRegressionPercent, 10, "maximumMemoryRegressionPercent");
|
|
const errors = [];
|
|
if (!document || typeof document !== "object" || Array.isArray(document)) {
|
|
return verdict(errors.concat("Evidence must be a JSON object."), [], minimumSpeedupPercent, maximumMemoryRegressionPercent);
|
|
}
|
|
const receiptBound = document.schemaVersion === 2 || document.schemaVersion === 3;
|
|
const packageBound = document.schemaVersion === 3;
|
|
const expectedEvidenceKeys = packageBound
|
|
? ["schemaVersion", "workloadId", "configuration", "memoryMeasurement", "sdkHeaderReceiptSha256", "addonReceiptSha256", "ccxReceiptSha256", "runs"]
|
|
: receiptBound
|
|
? ["schemaVersion", "workloadId", "configuration", "memoryMeasurement", "sdkHeaderReceiptSha256", "runs"]
|
|
: ["schemaVersion", "workloadId", "configuration", "memoryMeasurement", "runs"];
|
|
if (!sameKeys(document, expectedEvidenceKeys)) {
|
|
errors.push("Evidence must contain only the documented benchmark receipt fields.");
|
|
}
|
|
if (document.schemaVersion !== 1 && document.schemaVersion !== 2 && document.schemaVersion !== 3) {
|
|
errors.push("schemaVersion must be 1, 2, or 3.");
|
|
}
|
|
if (document.workloadId !== "weighted-energy-v1") errors.push("workloadId must be weighted-energy-v1.");
|
|
if (receiptBound && !/^[a-f0-9]{64}$/.test(String(document.sdkHeaderReceiptSha256 || ""))) {
|
|
errors.push("sdkHeaderReceiptSha256 must be a canonical SDK header receipt SHA-256 digest.");
|
|
}
|
|
if (packageBound && !/^[a-f0-9]{64}$/.test(String(document.addonReceiptSha256 || ""))) {
|
|
errors.push("addonReceiptSha256 must be a canonical addon-layout receipt SHA-256 digest.");
|
|
}
|
|
if (packageBound && !/^[a-f0-9]{64}$/.test(String(document.ccxReceiptSha256 || ""))) {
|
|
errors.push("ccxReceiptSha256 must be a canonical CCX receipt SHA-256 digest.");
|
|
}
|
|
const expectedConfiguration = { sampleCount: 30, warmupCount: 3, iterations: 4, inputLength: 131072, seed: 1337 };
|
|
if (!sameConfiguration(document.configuration, expectedConfiguration)) {
|
|
errors.push("configuration must match the versioned weighted-energy-v1 benchmark settings.");
|
|
}
|
|
if (typeof document.memoryMeasurement !== "string" || !document.memoryMeasurement.trim()) {
|
|
errors.push("memoryMeasurement must identify the process peak-working-set collection method.");
|
|
}
|
|
if (!Array.isArray(document.runs)) errors.push("runs must be an array.");
|
|
const runs = Array.isArray(document.runs) ? document.runs : [];
|
|
const targets = new Map();
|
|
const commits = new Set();
|
|
const sdkVersions = new Set();
|
|
for (let index = 0; index < runs.length; index += 1) {
|
|
const run = runs[index], prefix = `runs[${index}]`;
|
|
if (!run || typeof run !== "object" || Array.isArray(run)) {
|
|
errors.push(`${prefix} must be an object.`);
|
|
continue;
|
|
}
|
|
if (!sameKeys(run, ["platform", "arch", "hostVersion", "sdkVersion", "buildMode", "addonLoaded", "addonSha256", "sourceCommit", "checksumMatch", "codeSigned", "notarized", "javascript", "native"])) {
|
|
errors.push(`${prefix} must contain only the documented benchmark fields.`);
|
|
}
|
|
const target = `${run.platform || ""}-${run.arch || ""}`;
|
|
if (!REQUIRED_TARGETS.includes(target)) errors.push(`${prefix} has unsupported target ${target}.`);
|
|
else if (targets.has(target)) errors.push(`${prefix} duplicates target ${target}.`);
|
|
else targets.set(target, run);
|
|
if (!versionAtLeast(String(run.hostVersion || ""), "26.2.0")) {
|
|
errors.push(`${prefix}.hostVersion must be stable Premiere 26.2.0 or newer.`);
|
|
}
|
|
if (typeof run.sdkVersion !== "string" || !run.sdkVersion.trim()) errors.push(`${prefix}.sdkVersion is required.`);
|
|
else sdkVersions.add(run.sdkVersion);
|
|
if (run.buildMode !== "Release") errors.push(`${prefix}.buildMode must be Release.`);
|
|
if (run.addonLoaded !== true) errors.push(`${prefix}.addonLoaded must be true.`);
|
|
if (!/^[a-f0-9]{64}$/.test(String(run.addonSha256 || ""))) errors.push(`${prefix}.addonSha256 must be a lowercase SHA-256 digest.`);
|
|
if (!/^[a-f0-9]{40}$/.test(String(run.sourceCommit || ""))) errors.push(`${prefix}.sourceCommit must be a full Git SHA.`);
|
|
else commits.add(run.sourceCommit);
|
|
if (run.checksumMatch !== true) errors.push(`${prefix}.checksumMatch must be true.`);
|
|
if (target.startsWith("mac-") && (run.codeSigned !== true || run.notarized !== true)) {
|
|
errors.push(`${prefix} must record signed and notarized macOS addon evidence.`);
|
|
}
|
|
validateMetrics(run.javascript, `${prefix}.javascript`, errors);
|
|
validateMetrics(run.native, `${prefix}.native`, errors);
|
|
if (validMetrics(run.javascript) && validMetrics(run.native)) {
|
|
const p50Speedup = speedup(run.javascript.p50Ms, run.native.p50Ms);
|
|
const p95Speedup = speedup(run.javascript.p95Ms, run.native.p95Ms);
|
|
if (p50Speedup < minimumSpeedupPercent) errors.push(`${prefix} p50 speedup ${p50Speedup.toFixed(2)}% is below ${minimumSpeedupPercent}%.`);
|
|
if (p95Speedup < minimumSpeedupPercent) errors.push(`${prefix} p95 speedup ${p95Speedup.toFixed(2)}% is below ${minimumSpeedupPercent}%.`);
|
|
const jsMemory = run.javascript.peakWorkingSetBytes, nativeMemory = run.native.peakWorkingSetBytes;
|
|
const memoryRegression = (nativeMemory - jsMemory) / jsMemory * 100;
|
|
if (memoryRegression > maximumMemoryRegressionPercent) {
|
|
errors.push(`${prefix} memory regression ${memoryRegression.toFixed(2)}% exceeds ${maximumMemoryRegressionPercent}%.`);
|
|
}
|
|
}
|
|
}
|
|
for (const target of REQUIRED_TARGETS) if (!targets.has(target)) errors.push(`Missing required ${target} evidence.`);
|
|
if (commits.size > 1) errors.push("All runs must measure the same sourceCommit.");
|
|
if (commits.size === 0) errors.push("A shared full sourceCommit is required.");
|
|
if (sdkVersions.size > 1) errors.push("All runs must use the same UXP Hybrid SDK version.");
|
|
if (packageBound) validatePackageReceipts(document, options, sdkVersions, targets, errors);
|
|
else if (receiptBound) validateSdkReceipt(document, options.sdkHeaderReceipt, sdkVersions, errors);
|
|
if (packageBound) errors.push(LOCAL_CCX_ARCHIVE_REQUIRED);
|
|
return verdict(errors, Array.from(targets.keys()).sort(), minimumSpeedupPercent, maximumMemoryRegressionPercent, document.schemaVersion);
|
|
}
|
|
|
|
function validatePackageReceipts(document, options, sdkVersions, targets, errors) {
|
|
const { sdkHeaderReceipt, addonReceipt, ccxReceipt } = options;
|
|
if (!sdkHeaderReceipt) errors.push("A verified UXP Hybrid SDK header receipt is required.");
|
|
if (!addonReceipt) errors.push("A verified current UXP Hybrid addon-layout receipt is required.");
|
|
if (!ccxReceipt) errors.push("A verified UXP Hybrid CCX receipt is required.");
|
|
if (!sdkHeaderReceipt || !addonReceipt || !ccxReceipt) return;
|
|
try {
|
|
const sdk = verifyNativeSdkHeaderInventory(sdkHeaderReceipt);
|
|
if (sdk.sdk !== "uxp-hybrid") errors.push("SDK header receipt must identify uxp-hybrid.");
|
|
if (sdkVersions.size === 1 && sdkHeaderReceipt.source.sdkVersion !== Array.from(sdkVersions)[0]) {
|
|
errors.push("SDK header receipt sdkVersion must match all benchmark runs.");
|
|
}
|
|
if (document.sdkHeaderReceiptSha256 !== canonicalNativeSdkHeaderInventorySha256(sdkHeaderReceipt)) {
|
|
errors.push("sdkHeaderReceiptSha256 does not match the verified SDK header receipt.");
|
|
}
|
|
|
|
verifyUxpHybridAddonReceipt(addonReceipt, { sdkHeaderReceipt });
|
|
if (document.addonReceiptSha256 !== canonicalUxpHybridAddonReceiptSha256(addonReceipt)) {
|
|
errors.push("addonReceiptSha256 does not match the verified addon-layout receipt.");
|
|
}
|
|
|
|
verifyUxpHybridCcxReceipt(ccxReceipt, { addonReceipt, sdkHeaderReceipt });
|
|
if (document.ccxReceiptSha256 !== canonicalUxpHybridCcxReceiptSha256(ccxReceipt)) {
|
|
errors.push("ccxReceiptSha256 does not match the verified CCX receipt.");
|
|
}
|
|
|
|
for (const [target, run] of targets) {
|
|
const artifact = addonReceipt.artifacts.find((entry) => entry.target === target);
|
|
if (!artifact || run.addonSha256 !== artifact.sha256) {
|
|
errors.push(`runs for ${target} must match the corresponding addon-layout artifact SHA-256.`);
|
|
}
|
|
}
|
|
} catch (error) {
|
|
errors.push(`Hybrid package receipt is invalid: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
}
|
|
|
|
export async function verifyHybridBenchmarkEvidenceWithLocalCcx(document, options = {}) {
|
|
const result = verifyHybridBenchmarkEvidence(document, options);
|
|
if (document?.schemaVersion !== 3) return result;
|
|
const structuralErrors = result.errors.filter((error) => error !== LOCAL_CCX_ARCHIVE_REQUIRED);
|
|
if (structuralErrors.length > 0) return result;
|
|
if (typeof options.ccxPath !== "string" || !options.ccxPath.trim() || options.ccxPath.includes("\0")) {
|
|
return ineligible({ ...result, errors: structuralErrors }, "A local CCX archive path is required for schemaVersion 3.");
|
|
}
|
|
try {
|
|
const current = await buildUxpHybridCcxReceipt({
|
|
ccxPath: options.ccxPath,
|
|
addonReceipt: options.addonReceipt,
|
|
sdkHeaderReceipt: options.sdkHeaderReceipt,
|
|
});
|
|
if (canonicalUxpHybridCcxReceiptSha256(current) !== canonicalUxpHybridCcxReceiptSha256(options.ccxReceipt)) {
|
|
return ineligible({ ...result, errors: structuralErrors }, "CCX receipt does not match the supplied local archive.");
|
|
}
|
|
return { ...result, promotionEligible: true, errors: structuralErrors };
|
|
} catch (error) {
|
|
return ineligible({ ...result, errors: structuralErrors }, `CCX archive is invalid: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
}
|
|
|
|
function ineligible(result, error) {
|
|
return { ...result, promotionEligible: false, errors: [...result.errors, error] };
|
|
}
|
|
|
|
function validateSdkReceipt(document, receipt, sdkVersions, errors) {
|
|
if (!receipt) {
|
|
errors.push("A verified UXP Hybrid SDK header receipt is required.");
|
|
return;
|
|
}
|
|
try {
|
|
const summary = verifyNativeSdkHeaderInventory(receipt);
|
|
if (summary.sdk !== "uxp-hybrid") errors.push("SDK header receipt must identify uxp-hybrid.");
|
|
if (sdkVersions.size === 1 && receipt.source.sdkVersion !== Array.from(sdkVersions)[0]) {
|
|
errors.push("SDK header receipt sdkVersion must match all benchmark runs.");
|
|
}
|
|
if (document.sdkHeaderReceiptSha256 !== canonicalNativeSdkHeaderInventorySha256(receipt)) {
|
|
errors.push("sdkHeaderReceiptSha256 does not match the verified SDK header receipt.");
|
|
}
|
|
} catch (error) {
|
|
errors.push(`SDK header receipt is invalid: ${error instanceof Error ? error.message : String(error)}`);
|
|
}
|
|
}
|
|
|
|
function validateMetrics(value, label, errors) {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) {
|
|
errors.push(`${label} metrics are required.`);
|
|
return;
|
|
}
|
|
if (!sameKeys(value, ["sampleCount", "p50Ms", "p95Ms", "peakWorkingSetBytes"])) {
|
|
errors.push(`${label} must contain only the documented metric fields.`);
|
|
}
|
|
if (!Number.isInteger(value.sampleCount) || value.sampleCount < 20) errors.push(`${label}.sampleCount must be at least 20.`);
|
|
for (const key of ["p50Ms", "p95Ms", "peakWorkingSetBytes"]) {
|
|
if (!Number.isFinite(value[key]) || value[key] <= 0) errors.push(`${label}.${key} must be a positive finite number.`);
|
|
}
|
|
if (Number.isFinite(value.p50Ms) && Number.isFinite(value.p95Ms) && value.p95Ms < value.p50Ms) {
|
|
errors.push(`${label}.p95Ms cannot be lower than p50Ms.`);
|
|
}
|
|
}
|
|
|
|
function validMetrics(value) {
|
|
return value && Number.isFinite(value.p50Ms) && value.p50Ms > 0 && Number.isFinite(value.p95Ms) && value.p95Ms > 0 &&
|
|
Number.isFinite(value.peakWorkingSetBytes) && value.peakWorkingSetBytes > 0;
|
|
}
|
|
|
|
function speedup(baseline, candidate) {
|
|
return (baseline - candidate) / baseline * 100;
|
|
}
|
|
|
|
function sameConfiguration(value, expected) {
|
|
if (!value || typeof value !== "object" || Array.isArray(value)) return false;
|
|
const keys = Object.keys(expected);
|
|
return Object.keys(value).length === keys.length && keys.every((key) => value[key] === expected[key]);
|
|
}
|
|
|
|
function sameKeys(value, expected) {
|
|
return value && typeof value === "object" && !Array.isArray(value) &&
|
|
Object.keys(value).length === expected.length && expected.every((key) => Object.prototype.hasOwnProperty.call(value, key));
|
|
}
|
|
|
|
function versionAtLeast(value, minimum) {
|
|
if (!/^\d+\.\d+\.\d+$/.test(value)) return false;
|
|
const left = value.split(".").map(Number), right = minimum.split(".").map(Number);
|
|
for (let index = 0; index < 3; index += 1) {
|
|
if (left[index] > right[index]) return true;
|
|
if (left[index] < right[index]) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function finiteOption(value, fallback, name) {
|
|
const result = value == null ? fallback : Number(value);
|
|
if (!Number.isFinite(result) || result < 0 || result > 1000) throw new Error(`${name} must be between 0 and 1000.`);
|
|
return result;
|
|
}
|
|
|
|
function verdict(errors, targets, minimumSpeedupPercent, maximumMemoryRegressionPercent, schemaVersion) {
|
|
const verificationBoundary = schemaVersion === 3
|
|
? "submitted_cross_platform_release_build_and_verified_sdk_addon_ccx_receipt_evidence"
|
|
: schemaVersion === 2
|
|
? "submitted_cross_platform_release_build_and_verified_sdk_receipt_evidence"
|
|
: "submitted_cross_platform_release_build_evidence";
|
|
return {
|
|
promotionEligible: errors.length === 0,
|
|
errors,
|
|
targets,
|
|
thresholds: { minimumSpeedupPercent, maximumMemoryRegressionPercent },
|
|
verificationBoundary,
|
|
};
|
|
}
|
|
|
|
function parseArguments(argv) {
|
|
const result = {
|
|
input: null,
|
|
sdkHeaderReceipt: null,
|
|
addonReceipt: null,
|
|
ccxReceipt: null,
|
|
ccxPath: null,
|
|
minimumSpeedupPercent: 30,
|
|
maximumMemoryRegressionPercent: 10,
|
|
};
|
|
for (let index = 0; index < argv.length; index += 1) {
|
|
const value = argv[index];
|
|
if (value === "--input") result.input = argv[++index];
|
|
else if (value === "--sdk-header-receipt") result.sdkHeaderReceipt = argv[++index];
|
|
else if (value === "--addon-receipt") result.addonReceipt = argv[++index];
|
|
else if (value === "--ccx-receipt") result.ccxReceipt = argv[++index];
|
|
else if (value === "--ccx") result.ccxPath = argv[++index];
|
|
else if (value === "--min-speedup-percent") result.minimumSpeedupPercent = Number(argv[++index]);
|
|
else if (value === "--max-memory-regression-percent") result.maximumMemoryRegressionPercent = Number(argv[++index]);
|
|
else throw new Error(`Unknown argument: ${value}`);
|
|
}
|
|
if (!result.input) throw new Error("--input <evidence.json> is required.");
|
|
return result;
|
|
}
|
|
|
|
async function main() {
|
|
const args = parseArguments(process.argv.slice(2));
|
|
const [document, sdkHeaderReceipt, addonReceipt, ccxReceipt] = await Promise.all([
|
|
readEvidenceJson(args.input, "benchmark evidence"),
|
|
args.sdkHeaderReceipt ? readEvidenceJson(args.sdkHeaderReceipt, "SDK header receipt") : undefined,
|
|
args.addonReceipt ? readEvidenceJson(args.addonReceipt, "addon-layout receipt") : undefined,
|
|
args.ccxReceipt ? readEvidenceJson(args.ccxReceipt, "CCX receipt") : undefined,
|
|
]);
|
|
const result = await verifyHybridBenchmarkEvidenceWithLocalCcx(document, {
|
|
...args,
|
|
sdkHeaderReceipt,
|
|
addonReceipt,
|
|
ccxReceipt,
|
|
});
|
|
process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
|
|
if (!result.promotionEligible) process.exitCode = 1;
|
|
}
|
|
|
|
async function readEvidenceJson(path, label) {
|
|
try {
|
|
return JSON.parse(await readFile(path, "utf8"));
|
|
} catch {
|
|
throw new Error(`${label} must be a readable JSON document.`);
|
|
}
|
|
}
|
|
|
|
if (import.meta.url === pathToFileURL(process.argv[1] || "").href) {
|
|
main().catch((error) => {
|
|
process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
|
|
process.exitCode = 1;
|
|
});
|
|
}
|