From 2a158b8e5008dd971069693f7ab829f99df199e3 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:08:42 +0700 Subject: [PATCH 01/15] feat(factoryfx): discover real VST3 artifacts across four upstreams, including pre-releases --- scripts/factoryfx_upstream_watch.py | 80 +++++++++++++++++++++-------- 1 file changed, 58 insertions(+), 22 deletions(-) diff --git a/scripts/factoryfx_upstream_watch.py b/scripts/factoryfx_upstream_watch.py index 90008ec53..3b6e33aa1 100644 --- a/scripts/factoryfx_upstream_watch.py +++ b/scripts/factoryfx_upstream_watch.py @@ -1,5 +1,10 @@ #!/usr/bin/env python3 -"""Inventory only: never auto-approve, download or promote upstream binary releases.""" +"""Observe first-party Windows x64 VST3 releases without authorising redistribution. + +Selection is by *actual VST3 asset*, not GitHub's releases/latest (which omits +prereleases and can point to a standalone-only stable release). The watcher is +metadata-only: an observed binary can NEVER modify the reviewed FactoryFX lock. +""" import json import os import sys @@ -9,13 +14,50 @@ PRODUCTS = [ ("arson-eq", "masarray/arson-eq"), + ("arson-comp", "masarray/arson-comp"), ("arson-verb", "masarray/arsonverb"), + # The Chrome extension is NOT a VST3. Public binary distribution is here; + # original proprietary DSP/source is in the separate askp-vst repository. ("arsonkupik-enhancer", "masarray/vst-enhancer"), ] +def windows_vst3_assets(release): + return sorted( + a["name"] for a in release.get("assets", []) + if isinstance(a, dict) and isinstance(a.get("name"), str) + and "windows" in a["name"].lower() + and "x64" in a["name"].lower() + and "vst3" in a["name"].lower() + and a["name"].lower().endswith(".zip") + ) + + +def select_candidate(releases, repo): + """Choose latest published VST3-bearing release, including test prereleases. + + A newer standalone-only release must not hide a compatible VST3 artifact. + Ambiguous release archives are rejected rather than chosen arbitrarily. + """ + if not isinstance(releases, list): + raise ValueError(repo + ": malformed GitHub releases response") + matches = [] + for release in releases: + if not isinstance(release, dict) or release.get("draft"): + continue + names = windows_vst3_assets(release) + if len(names) > 1: + raise ValueError(repo + ": ambiguous Windows x64 VST3 assets in " + + str(release.get("tag_name"))) + if names: + if not release.get("tag_name") or not release.get("published_at"): + raise ValueError(repo + ": missing published release identity") + matches.append(release) + return max(matches, key=lambda x: (x["published_at"], x["tag_name"])) if matches else None + def latest(repo): - url = "https://api.github.com/repos/" + repo + "/releases/latest" + # Bounded metadata request: does not download .vst3 or build plugin source. + url = "https://api.github.com/repos/" + repo + "/releases?per_page=30" headers = { "Accept": "application/vnd.github+json", "User-Agent": "ArSonMix-FactoryFX-Candidate-Watch", @@ -25,14 +67,11 @@ def latest(repo): headers["Authorization"] = "Bearer " + os.environ["GITHUB_TOKEN"] try: with urllib.request.urlopen(urllib.request.Request(url, headers=headers), timeout=20) as response: - release = json.load(response) + return select_candidate(json.load(response), repo) except urllib.error.HTTPError as error: - if error.code == 404: # No public release, not a successful plugin qualification. + if error.code == 404: return None raise - if release.get("draft") or release.get("prerelease"): - return None - return release def snapshot(fetch=latest): @@ -41,21 +80,15 @@ def snapshot(fetch=latest): release = fetch(repo) if release is None: row = dict(productId=product_id, distributionRepo=repo, releaseTag=None, - publishedAt=None, windowsVst3Asset=None) + publishedAt=None, windowsVst3Asset=None, prerelease=None) else: - assets = [ - a["name"] for a in release.get("assets", []) - if isinstance(a.get("name"), str) - and "windows" in a["name"].lower() - and "x64" in a["name"].lower() - and "vst3" in a["name"].lower() - and a["name"].lower().endswith(".zip") - ] - if len(assets) > 1: - raise ValueError(repo + ": ambiguous Windows x64 VST3 release assets") + names = windows_vst3_assets(release) + if len(names) != 1: + raise ValueError(repo + ": selected release has no unique VST3 asset") row = dict(productId=product_id, distributionRepo=repo, releaseTag=release["tag_name"], publishedAt=release["published_at"], - windowsVst3Asset=assets[0] if assets else None) + windowsVst3Asset=names[0], + prerelease=bool(release.get("prerelease", False))) observed.append(row) return {"schemaVersion": 1, "observed": observed} @@ -66,10 +99,13 @@ def snapshot(fetch=latest): candidate = snapshot() rendered = json.dumps(candidate, indent=2, ensure_ascii=False) + "\n" output.parent.mkdir(parents=True, exist_ok=True) - output.write_text(rendered, encoding="utf-8") + if not output.exists() or output.read_text(encoding="utf-8") != rendered: + output.write_text(rendered, encoding="utf-8") for item in candidate["observed"]: - print(item["productId"] + ": " + str(item["releaseTag"]) + " / " + str(item["windowsVst3Asset"])) - print("CANDIDATE ONLY — no redistribution, host certification or factory promotion") + print(item["productId"] + ": " + str(item["releaseTag"]) + + " / " + str(item["windowsVst3Asset"]) + + (" (TEST candidate)" if item["prerelease"] else "")) + print("OBSERVATION ONLY — not approved, licensed, host-qualified or bundled") except (OSError, ValueError, KeyError, urllib.error.URLError) as error: print("RELEASE WATCH FAILED: " + str(error), file=sys.stderr) sys.exit(1) From f2ce3e3ebe240e8198bd9421d79d4d53c8e8dab5 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:09:18 +0700 Subject: [PATCH 02/15] feat(factoryfx): transactional all-or-nothing four-FX staging and locked production release gate --- scripts/factoryfx_release_bundle.py | 57 ++++++++++++++++++++++------- 1 file changed, 44 insertions(+), 13 deletions(-) diff --git a/scripts/factoryfx_release_bundle.py b/scripts/factoryfx_release_bundle.py index 0a2334ff6..ceecc6e58 100644 --- a/scripts/factoryfx_release_bundle.py +++ b/scripts/factoryfx_release_bundle.py @@ -25,6 +25,18 @@ "arson-harmony": ("masarray/arson-harmony", "ArSonHarmony", "ArSonHarmony.vst3", "HARMONY"), "arson-color": ("masarray/arson-color", "ArSonColor", "ArSonColor.vst3", "COLOR"), } +FOUR_IDS = frozenset(("arson-eq", "arson-comp", "arson-verb", "arsonkupik-enhancer")) + + +def distribution_for(plugins): + ids = [p["productId"] for p in plugins] + if len(ids) == 6 and set(ids) == set(OWNED): + return "production-six" + if len(ids) == 4 and set(ids) == FOUR_IDS: + return "production-four" + return "engineering-partial" + + HEX = lambda s, n: isinstance(s, str) and re.fullmatch("[0-9a-fA-F]{" + str(n) + "}", s) is not None TOKEN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,119}$") MAX_UNPACKED = 200 * 1024 * 1024 @@ -121,7 +133,7 @@ def zip_members(z, bundle): # Standalone EXEs and foreign plugins must never enter the factory. continue i = positions[0] - if i > 1 or (i == 1 and parts[0] not in ("VST3", "vst3")): + if i > 1 or (i == 1 and parts[0] not in ("VST3", "vst3", "Plugin")): fail("unexpected VST3 archive root") sub = parts[i + 1:] if not sub: @@ -143,14 +155,25 @@ def zip_members(z, bundle): def stage(plugins, output, notices): - factory = output / "FactoryFX" - if factory.exists(): + """Build the WHOLE factory off to the side; publish only after full verify. + + A partial download, invalid ZIP, bad notice or failed integrity check must + leave the existing installed/package FactoryFX untouched. Temporary files + are on the same filesystem so the final directory rename is atomic. + """ + output = Path(output) + output.mkdir(parents=True, exist_ok=True) + destination = output / "FactoryFX" + if destination.exists() or destination.is_symlink(): fail("staging must start with clean FactoryFX destination") if not plugins: print("FACTORYFX: no approved plugins; app-only engineering package unchanged") return - with tempfile.TemporaryDirectory(prefix="arsonmix-factoryfx-") as work: + with tempfile.TemporaryDirectory(prefix=".factoryfx-incoming-", dir=output) as work: temp = Path(work) + staging = temp / "staged" + staging.mkdir() + factory = staging / "FactoryFX" rows = [] for p in plugins: pid = p["productId"] @@ -184,14 +207,16 @@ def stage(plugins, output, notices): }) manifest = { "schemaVersion": 1, "platform": "windows-x64", "hostFormat": "VST3", - "distribution": "production-six" if len(rows) == 6 else "engineering-partial", - "plugins": rows, + "distribution": distribution_for(plugins), "plugins": rows, } (factory / "factoryfx-manifest.json").write_text( json.dumps(manifest, indent=2) + "\n", encoding="utf-8") - verify(plugins, output, notices) - print("FACTORYFX staged and verified: " + ", ".join(x["productId"] for x in rows)) - + # Verify staging BEFORE revealing it to runtime, packaging, or installer. + verify(plugins, staging, notices) + if destination.exists() or destination.is_symlink(): + fail("concurrent FactoryFX staging detected") + factory.rename(destination) + print("FACTORYFX staged and verified: " + ", ".join(x["productId"] for x in rows)) def verify(plugins, output, notices): factory = output / "FactoryFX" @@ -203,7 +228,7 @@ def verify(plugins, output, notices): if not manifest_path.is_file(): fail("missing FactoryFX manifest") m = json.loads(manifest_path.read_text(encoding="utf-8")) - if m.get("distribution") != ("production-six" if len(plugins) == 6 else "engineering-partial"): + if m.get("distribution") != distribution_for(plugins): fail("FactoryFX distribution level mismatch") rows = m.get("plugins") if not isinstance(rows, list) or len(rows) != len(plugins): @@ -241,6 +266,10 @@ def verify(plugins, output, notices): if file.is_symlink() or not file.is_file() or sha256(file) != entry["sha256"]: fail(pid + ": missing or modified resource " + relative) allowed_files.add(file.relative_to(factory).as_posix()) + # Never follow or tolerate symlinks, including directory junctions. + for item in factory.rglob("*"): + if item.is_symlink() or not (item.is_dir() or item.is_file()): + fail("FactoryFX contains symlink or special filesystem entry") actual = {x.relative_to(factory).as_posix() for x in factory.rglob("*") if x.is_file()} if actual != allowed_files: fail("FactoryFX untracked/extra resource or user content found") @@ -252,13 +281,15 @@ def main(): parser.add_argument("--lock", default="config/factoryfx-approved-releases.json") parser.add_argument("--notices", default="config/factoryfx-notices") parser.add_argument("--output", default="dist") - parser.add_argument("--require", choices=["none", "factory", "six"], default="none") + parser.add_argument("--require", choices=["none", "factory", "four", "six"], default="none") args = parser.parse_args() plugins = read_lock(args.lock) if args.require == "factory" and not plugins: fail("Factory FX required but no approved release") - if args.require == "six" and len(plugins) != 6: - fail("Production bundle requires all six approved effects") + if args.require == "four" and distribution_for(plugins) != "production-four": + fail("Four-FX release requires EQ, Comp, Verb and KuPik — all approved") + if args.require == "six" and distribution_for(plugins) != "production-six": + fail("Six-FX release requires all six approved effects") if args.action == "stage": stage(plugins, Path(args.output), Path(args.notices)) else: From e4cf55e499317e362ee42e2be650e8a0a3b5981c Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:10:00 +0700 Subject: [PATCH 03/15] test(factoryfx): four real-source layout, prerelease selection, atomic failure and production contract --- .../tests/test_factoryfx_release_bundle.py | 107 +++++++++++++++++- 1 file changed, 104 insertions(+), 3 deletions(-) diff --git a/scripts/tests/test_factoryfx_release_bundle.py b/scripts/tests/test_factoryfx_release_bundle.py index d5ba6e88f..f939fd876 100644 --- a/scripts/tests/test_factoryfx_release_bundle.py +++ b/scripts/tests/test_factoryfx_release_bundle.py @@ -108,17 +108,118 @@ def test_extra_factory_file_is_rejected(self): bundle.verify(bundle.read_lock(self.lock), self.output, self.notices) + def test_comp_plugin_archive_layout_excludes_standalone(self): + with zipfile.ZipFile(self.root / "comp.zip", "w") as z: + z.writestr("Plugin/ArSonComp.vst3/Contents/x86_64-win/ArSonComp.vst3", + b"mock-comp-PE") + z.writestr("Standalone/ArSonComp.exe", b"NEVER SHIP") + with zipfile.ZipFile(self.root / "comp.zip") as z: + selected = bundle.zip_members(z, "ArSonComp.vst3") + self.assertEqual(len(selected), 1) + self.assertEqual(selected[0][1], "Contents/x86_64-win/ArSonComp.vst3") + + def test_four_product_production_gate_and_full_atomic_staging(self): + archives, releases = {}, [] + for pid in ("arson-eq", "arson-comp", "arson-verb", "arsonkupik-enhancer"): + repo, display, filename, _category = bundle.OWNED[pid] + archive = self.root / (pid + ".zip") + with zipfile.ZipFile(archive, "w") as z: + base = "Plugin" if pid == "arson-comp" else "VST3" + z.writestr(f"{base}/{filename}/Contents/x86_64-win/{filename}", + pid.encode("ascii") + b"-DSP-test") + archives[pid] = archive + (self.notices / (pid + ".txt")).write_text( + "Reviewed release fixture " + pid, encoding="utf-8") + releases.append(dict( + self.approved, productId=pid, + sourceRepo="masarray/askp-vst" if pid == "arsonkupik-enhancer" else repo, + assetName=display + "-Windows-x64-VST3.zip", + artifactSha256=hashlib.sha256(archive.read_bytes()).hexdigest(), + hostUniqueId=12345 + len(releases))) + self.save_lock(*releases) + locked = bundle.read_lock(self.lock) + self.assertEqual(bundle.distribution_for(locked), "production-four") + with patch.object(bundle, "download_release", + side_effect=lambda p, target: shutil.copyfile(archives[p["productId"]], target)): + bundle.stage(locked, self.output, self.notices) + bundle.verify(locked, self.output, self.notices) + manifest_path = self.output / "FactoryFX/factoryfx-manifest.json" + manifest = json.loads(manifest_path.read_text()) + self.assertEqual(manifest["distribution"], "production-four") + self.assertEqual(len(manifest["plugins"]), 4) + self.assertFalse(list(self.output.glob(".factoryfx-incoming-*"))) + # Fake production branding cannot turn a three-effect package into four. + manifest["plugins"].pop() + manifest_path.write_text(json.dumps(manifest)) + with self.assertRaises(ValueError): + bundle.verify(locked, self.output, self.notices) + self.assertEqual(bundle.distribution_for(releases[:3]), "engineering-partial") + + def test_failed_second_artifact_never_publishes_partial_factory(self): + p = dict(self.approved, productId="arson-verb", + sourceRepo="masarray/arsonverb", + assetName="ArSonVerb-Windows-x64-VST3.zip") + (self.notices / "arson-verb.txt").write_text( + "Reviewed Reverb fixture", encoding="utf-8") + self.save_lock(self.approved, p) + def fake_download(release, target): + if release["productId"] != "arson-eq": + raise ValueError("download failed") + shutil.copyfile(self.archive, target) + with patch.object(bundle, "download_release", side_effect=fake_download): + with self.assertRaisesRegex(ValueError, "download failed"): + bundle.stage(bundle.read_lock(self.lock), self.output, self.notices) + self.assertFalse((self.output / "FactoryFX").exists()) + self.assertFalse(list(self.output.glob(".factoryfx-incoming-*"))) + + def test_production_names_are_exact_not_count_only(self): + refs = [dict(self.approved, productId=pid) for pid in + ("arson-eq", "arson-comp", "arson-harmony", "arson-color")] + self.assertEqual(bundle.distribution_for(refs), "engineering-partial") + + class WatchTests(unittest.TestCase): - def test_latest_is_metadata_only_and_absent_release_not_a_plugin(self): + def test_four_suppliers_are_monitored_and_missing_is_not_approved(self): def fake(repo): if repo == "masarray/vst-enhancer": return dict(tag_name="v0.5.26", published_at="2026-08-23T23:40:39Z", + prerelease=False, assets=[{"name": "ArSonKuPik-v0.5.26-Windows-x64-VST3.zip"}]) return None snapshot = watch.snapshot(fake) - self.assertEqual(len(snapshot["observed"]), 3) + self.assertEqual([x["productId"] for x in snapshot["observed"]], + ["arson-eq", "arson-comp", "arson-verb", "arsonkupik-enhancer"]) self.assertIsNone(snapshot["observed"][0]["releaseTag"]) - self.assertEqual(snapshot["observed"][2]["releaseTag"], "v0.5.26") + self.assertEqual(snapshot["observed"][3]["releaseTag"], "v0.5.26") + self.assertNotIn("approved", json.dumps(snapshot)) + + def test_standalone_stable_cannot_hide_newer_usable_integration_vst3(self): + releases = [ + dict(tag_name="v0.2.0", published_at="2026-11-01T07:59:05Z", + draft=False, prerelease=False, + assets=[{"name": "ArSonComp-0.2.0-Windows-x64-Setup.exe"}]), + dict(tag_name="v0.2.0-sc220-vst3-test", + published_at="2026-11-03T23:42:19Z", draft=False, + prerelease=True, + assets=[{"name": "ArSonComp-v0.2.0-Windows-x64-VST3.zip"}]), + ] + selected = watch.select_candidate(releases, "masarray/arson-comp") + self.assertEqual(selected["tag_name"], "v0.2.0-sc220-vst3-test") + snap = watch.snapshot(lambda repo: selected if repo == "masarray/arson-comp" else None) + self.assertTrue(snap["observed"][1]["prerelease"]) + self.assertEqual(snap["observed"][1]["windowsVst3Asset"], + "ArSonComp-v0.2.0-Windows-x64-VST3.zip") + + def test_ambiguous_binaries_and_drafts_fail_closed(self): + releases = [ + dict(tag_name="draft", published_at="2026-11-09", draft=True, + assets=[{"name": "ArSonComp-Windows-x64-VST3.zip"}]), + dict(tag_name="bad", published_at="2026-11-08", draft=False, assets=[ + {"name": "one-Windows-x64-VST3.zip"}, + {"name": "two-Windows-x64-VST3.zip"}])] + with self.assertRaisesRegex(ValueError, "ambiguous"): + watch.select_candidate(releases, "masarray/arson-comp") + self.assertIsNone(watch.select_candidate(releases[:1], "masarray/arson-comp")) if __name__ == "__main__": From 6cbdd95e56dd4e7bbf5edfba0d570b31e74356b3 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:10:43 +0700 Subject: [PATCH 04/15] feat(factoryfx): recognize strict four-plugin production manifests in native registry --- src/FactoryFxRegistry.h | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/src/FactoryFxRegistry.h b/src/FactoryFxRegistry.h index f195f041a..805cb03c2 100644 --- a/src/FactoryFxRegistry.h +++ b/src/FactoryFxRegistry.h @@ -101,7 +101,8 @@ struct Registry final data.getProperty ("hostFormat", {}).toString() != "VST3") return fail ("incompatible manifest version/platform"); const auto distribution = data.getProperty ("distribution", {}).toString(); - if (distribution != "engineering-partial" && distribution != "production-six") + if (distribution != "engineering-partial" && distribution != "production-four" && + distribution != "production-six") return fail ("unknown distribution type"); const auto plugins = data.getProperty ("plugins", {}); @@ -164,6 +165,14 @@ struct Registry final result.candidates.push_back ({ id, bundle.getFullPathName(), static_cast (item.getProperty ("hostUniqueId", 0)) }); } + // Official four-FX packs require the exact reviewed original suppliers. + if (distribution == "production-four") + { + static const std::set required { + "arson-eq", "arson-comp", "arson-verb", "arsonkupik-enhancer" }; + if (seen != required) + return fail ("production-four manifest requires EQ, Comp, Verb, KuPik"); + } if (distribution == "production-six" && result.candidates.size() != 6) return fail ("production manifest must contain all six effects"); return result; From eedcfcc688fa1cf583e00eef1a2da03e8d0f667c Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:10:55 +0700 Subject: [PATCH 05/15] feat(factoryfx): update four VST3 candidate contract and release manifest schema --- docs/factoryfx-release-manifest.schema.json | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/factoryfx-release-manifest.schema.json b/docs/factoryfx-release-manifest.schema.json index 60c626b5f..70919937c 100644 --- a/docs/factoryfx-release-manifest.schema.json +++ b/docs/factoryfx-release-manifest.schema.json @@ -24,6 +24,7 @@ "distribution": { "enum": [ "engineering-partial", + "production-four", "production-six" ] }, From edfffd6ae3bf12c42b483ee70f3c4cb8ce9d0460 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:10:58 +0700 Subject: [PATCH 06/15] feat(factoryfx): update four VST3 candidate contract and release manifest schema --- .github/workflows/factoryfx-release-watch.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/factoryfx-release-watch.yml b/.github/workflows/factoryfx-release-watch.yml index 18664109c..da5c88290 100644 --- a/.github/workflows/factoryfx-release-watch.yml +++ b/.github/workflows/factoryfx-release-watch.yml @@ -31,9 +31,9 @@ jobs: commit-message: 'chore(factoryfx): record latest upstream release candidates' branch: bot/factoryfx-release-candidates delete-branch: true - title: 'FactoryFX: review new EQ/Verb/Enhancer releases (metadata only)' + title: 'FactoryFX: review EQ/Comp/Verb/KuPik VST3 candidates (metadata only)' body: | - Upstream release discovery only. NO plugin is qualified, downloaded, + VST3 release discovery (including test prereleases) only. NO plugin is qualified, downloaded, licensed, shipped or enabled by this PR. Inspect provenance, complete Windows VST3 ZIP, host UID/CID, licence/entitlement and Show migration before separately promoting From a73d7a77c8998833da5615759417105c9b9cf52b Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:11:00 +0700 Subject: [PATCH 07/15] feat(factoryfx): update four VST3 candidate contract and release manifest schema --- config/factoryfx-upstream-candidates.json | 25 ++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/config/factoryfx-upstream-candidates.json b/config/factoryfx-upstream-candidates.json index 2529023f0..8531c8e0b 100644 --- a/config/factoryfx-upstream-candidates.json +++ b/config/factoryfx-upstream-candidates.json @@ -4,23 +4,34 @@ { "productId": "arson-eq", "distributionRepo": "masarray/arson-eq", - "releaseTag": null, - "publishedAt": null, - "windowsVst3Asset": null + "releaseTag": "v0.1.0-m3.1-sc220-test", + "publishedAt": "2026-11-03T23:42:18Z", + "windowsVst3Asset": "ArSonEQ-v0.1.0-M3.1-Windows-x64-VST3.zip", + "prerelease": true + }, + { + "productId": "arson-comp", + "distributionRepo": "masarray/arson-comp", + "releaseTag": "v0.2.0-sc220-vst3-test", + "publishedAt": "2026-11-03T23:42:19Z", + "windowsVst3Asset": "ArSonComp-v0.2.0-Windows-x64-VST3.zip", + "prerelease": true }, { "productId": "arson-verb", "distributionRepo": "masarray/arsonverb", - "releaseTag": null, - "publishedAt": null, - "windowsVst3Asset": null + "releaseTag": "v1.0.1", + "publishedAt": "2026-10-31T22:34:11Z", + "windowsVst3Asset": "ArSonVerb-Windows-x64-VST3-v1.0.1.zip", + "prerelease": false }, { "productId": "arsonkupik-enhancer", "distributionRepo": "masarray/vst-enhancer", "releaseTag": "v0.5.26", "publishedAt": "2026-08-23T23:40:39Z", - "windowsVst3Asset": "ArSonKuPik-v0.5.26-Windows-x64-VST3.zip" + "windowsVst3Asset": "ArSonKuPik-v0.5.26-Windows-x64-VST3.zip", + "prerelease": false } ] } From 8e979bdd46b2aef15a3e002ab0e02777ba12804e Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:11:47 +0700 Subject: [PATCH 08/15] test(factoryfx): reject falsely advertised incomplete native four-FX production manifest --- tests/factory_fx_registry_test.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/tests/factory_fx_registry_test.cpp b/tests/factory_fx_registry_test.cpp index 0d704eb5f..750bd7267 100644 --- a/tests/factory_fx_registry_test.cpp +++ b/tests/factory_fx_registry_test.cpp @@ -75,11 +75,17 @@ int main() if (! check (! scan.ok(), "six-effect production manifest cannot claim one effect")) return 6; + manifest.replaceWithText (original.replace ("engineering-partial", "production-four")); + scan = armix::factory::Registry::discover (root); + if (! check (! scan.ok() && scan.candidates.empty(), + "four-effect production manifest cannot claim one effect")) + return 8; + manifest.deleteFile(); scan = armix::factory::Registry::discover (root); if (! check (! scan.ok() && scan.candidates.empty(), "missing manifest rejected")) return 7; - std::cout << "FactoryFX registry: valid package + 6 negative gates passed\n"; + std::cout << "FactoryFX registry: valid package + 7 negative gates passed\n"; return 0; } From fb25f46326c82c8f871828c91c5269637f764b85 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:13:50 +0700 Subject: [PATCH 09/15] perf(factoryfx): expose immutable artifact identity for verified metadata caching --- src/FactoryFxRegistry.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/FactoryFxRegistry.h b/src/FactoryFxRegistry.h index 805cb03c2..9eaf21fd7 100644 --- a/src/FactoryFxRegistry.h +++ b/src/FactoryFxRegistry.h @@ -15,6 +15,7 @@ struct Candidate { juce::String productId, path; int hostUniqueId = 0; + juce::String artifactSha256; // Fixed, approved ZIP identity for cold-scan metadata cache. }; struct Discovery @@ -163,7 +164,8 @@ struct Registry final return fail (id + ": modified VST3 resource"); } result.candidates.push_back ({ id, bundle.getFullPathName(), - static_cast (item.getProperty ("hostUniqueId", 0)) }); + static_cast (item.getProperty ("hostUniqueId", 0)), + item.getProperty ("artifactSha256", {}).toString() }); } // Official four-FX packs require the exact reviewed original suppliers. if (distribution == "production-four") From 99e988d8391ceb70dc8a3a10065b611840404686 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:14:21 +0700 Subject: [PATCH 10/15] perf(factoryfx): cache verified VST3 descriptors while rehashing original binaries off realtime thread --- src/PluginCatalog.h | 59 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 55 insertions(+), 4 deletions(-) diff --git a/src/PluginCatalog.h b/src/PluginCatalog.h index 9b7899964..6d98e0890 100644 --- a/src/PluginCatalog.h +++ b/src/PluginCatalog.h @@ -23,6 +23,7 @@ struct CatalogEntry bool favorite = false; // Portable user preference; never inferred from vendor scanner. bool factory = false; // Verified app-managed binary, not user Vault. juce::String factoryProductId; + juce::String factoryArtifactSha256; // Reviewed binary SHA; validated by Registry before reuse. juce::String key() const { return path + "|" + juce::String (uid) + "|" + juce::String (variant); } @@ -38,7 +39,11 @@ struct CatalogEntry o->setProperty ("variant", variant); o->setProperty ("favorite", favorite); o->setProperty ("source", factory ? "factory" : "user"); - if (factory) o->setProperty ("factoryProductId", factoryProductId); + if (factory) + { + o->setProperty ("factoryProductId", factoryProductId); + o->setProperty ("factoryArtifactSha256", factoryArtifactSha256); + } return juce::var (o.release()); } @@ -54,6 +59,7 @@ struct CatalogEntry e.favorite = static_cast (v.getProperty ("favorite", false)); e.factory = v.getProperty ("source", {}).toString() == "factory"; e.factoryProductId = v.getProperty ("factoryProductId", {}).toString(); + e.factoryArtifactSha256 = v.getProperty ("factoryArtifactSha256", {}).toString(); return e; } }; @@ -188,6 +194,7 @@ class PluginCatalog final for (const auto& entry : entries_) list.add (entry.toVar()); o->setProperty ("items", juce::var (list)); + o->setProperty ("verifiedFactory", juce::var (verifiedFactory)); o->setProperty ("scanning", busy()); o->setProperty ("message", scanMessage_); o->setProperty ("count", static_cast (entries_.size())); @@ -216,6 +223,17 @@ class PluginCatalog final ? armix::factory::Registry::discover (armix::factory::Registry::executableRoot()) : armix::factory::Discovery{}; if (factoryOnly_ && ! factory.ok()) importErrors = factory.error; + // The cache is metadata ONLY. Verified binaries/resources are rehashed + // first by Registry on this worker; a cache file cannot authorise FX. + juce::var cachedFactory; + if (factoryOnly_ && factory.ok()) + { + const auto file = owner_.dataFolder_.getChildFile ("plugin-catalog.json"); + if (file.existsAsFile() && file.getSize() <= 128 * 1024) + cachedFactory = juce::JSON::parse (file); + } + const auto cachedItems = cachedFactory.getProperty ("verifiedFactory", {}); + const auto* verifiedCache = cachedItems.getArray(); // 1. Enumerate candidates. Total cannot be estimated here. owner_.phase_.store (1, std::memory_order_release); if (factoryOnly_ && factory.ok()) @@ -261,7 +279,33 @@ class PluginCatalog final const juce::ScopedLock lock (owner_.progressLock_); owner_.current_ = juce::File (path).getFileName(); } - if (format.fileMightContainThisPluginType (path)) + bool usedVerifiedCache = false; + if (factoryOnly_ && verifiedCache != nullptr && verifiedCache->size() <= 64) + { + const auto approved = std::find_if (factory.candidates.begin(), factory.candidates.end(), + [&path] (const armix::factory::Candidate& c) { return c.path == path; }); + if (approved != factory.candidates.end()) + for (const auto& item : *verifiedCache) + { + if (! item.isObject()) continue; + auto entry = CatalogEntry::fromVar (item); + if (! entry.factory || entry.factoryProductId != approved->productId || + entry.path != path || entry.uid != approved->hostUniqueId || + ! entry.factoryArtifactSha256.equalsIgnoreCase (approved->artifactSha256) || + entry.name.isEmpty() || entry.name.length() > 120 || + entry.variant < 0 || entry.variant >= 16) + continue; + if (std::none_of (found.begin(), found.end(), [&entry] (const CatalogEntry& e) + { return e.key() == entry.key(); })) + { + found.push_back (std::move (entry)); + usedVerifiedCache = true; + } + } + } + // Cold run after a new FactoryFX release still inspects the + // real VST3 class; subsequent starts reuse its verified identity. + if (! usedVerifiedCache && format.fileMightContainThisPluginType (path)) { juce::OwnedArray descriptions; format.findAllTypesForFile (descriptions, path); @@ -280,6 +324,7 @@ class PluginCatalog final if (it == factory.candidates.end()) continue; entry.factory = true; entry.factoryProductId = it->productId; + entry.factoryArtifactSha256 = it->artifactSha256; } found.push_back (std::move (entry)); } @@ -397,10 +442,16 @@ class PluginCatalog final void save() { auto o = std::make_unique(); - juce::Array list, folders; + juce::Array list, verifiedFactory, folders; for (const auto& entry : entries_) { - if (entry.factory) continue; // Never persist an unverified factory binary path. + // Factory descriptors are a cold-scan accelerator, never an + // authority: load() must NOT expose them until Registry rehashes. + if (entry.factory) + { + verifiedFactory.add (entry.toVar()); + continue; + } auto item = entry.toVar(); item.getDynamicObject()->setProperty ("path", armix::storage::PortableWorkspace::encode (dataFolder_, juce::File (entry.path))); From 47b280384ab6d4792d3be9b3e36e4d81d2805f2a Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:14:49 +0700 Subject: [PATCH 11/15] test(factoryfx): require verified cache not user Vault and production-four schema --- tests/plugin_ui_contract_test.mjs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/tests/plugin_ui_contract_test.mjs b/tests/plugin_ui_contract_test.mjs index 119f3cd59..2624320f5 100644 --- a/tests/plugin_ui_contract_test.mjs +++ b/tests/plugin_ui_contract_test.mjs @@ -266,7 +266,11 @@ test('FXF1 manifest parser is fail-closed and factory entries do not persist in assert.match(catalog,/scanFactoryIfPresent/); assert.match(catalog,/factoryOnly_/); assert.match(catalog,/factoryFavorites_/); - assert.match(catalog,/if \(entry.factory\) continue/); + assert.match(catalog,/verifiedFactory\.add \(entry\.toVar\(\)\)/); + assert.match(catalog,/if \(! entry\.factory && entry\.path\.isNotEmpty\(\)\)/); + assert.match(catalog,/approved->artifactSha256/); + assert.match(catalog,/usedVerifiedCache/); + assert.ok(schema.properties.distribution.enum.includes('production-four')); assert.match(native,/catalog_\.scanFactoryIfPresent\(\)/); assert.match(cmake,/FactoryFxVerifiedManifestAndNegativePathGate/); }); From 3e854919b355c356859deb6f079cc2c680562497 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:16:05 +0700 Subject: [PATCH 12/15] docs(factoryfx): four-VST3 production acceptance, integrity and cold-start contracts --- ...TORYFX_FOUR_VST3_RELEASE_GATES_20261108.md | 77 +++++++++++++++++++ 1 file changed, 77 insertions(+) create mode 100644 docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md diff --git a/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md b/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md new file mode 100644 index 000000000..8ecafab8a --- /dev/null +++ b/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md @@ -0,0 +1,77 @@ +# FXF4 — Four first-party VST3 FactoryFX release path (2026-11-08) + +## Product outcome +The first public four-FX ArSonMix package must contain **ArSonEQ, ArSonComp, +ArSonVerb and ArSonKuPik Enhancer** in both the portable ZIP and Inno installer. +The native Parametric EQ already compiled into ArSonMix is a separate built-in +insert and remains available irrespective of external VST3 packaging. + +This milestone completes the *four-product release intake, transactional stage, +production-four schema and verified cold-scan metadata cache*. It does **not** +misrepresent an empty approved lock as shipped binaries or claim physical FAT. + +## Actual upstream binary authorities +| Product | Exact current public Windows VST3 candidate | Review status | +| --- | --- | --- | +| EQ | masarray/arson-eq, v0.1.0-m3.1-sc220-test | Prerelease/test; newer CI artifact is NOT a GitHub release | +| Comp | masarray/arson-comp, v0.2.0-sc220-vst3-test | Prerelease/test; stable v0.2.0 has Setup EXE, not VST3 ZIP | +| Verb | masarray/arsonverb, v1.0.1 | Published stable, AGPL-3.0-only | +| KuPik | masarray/vst-enhancer, v0.5.26 (DSP source: masarray/askp-vst) | Proprietary EULA/activation; redistribution and factory entitlement need recorded approval | + +Release metadata watch includes *prereleases* solely as candidates. It excludes +drafts, ambiguous multi-VST3 ZIP listings, unrelated Chrome extension source +and standalone EXE artifacts. It does not automatically change +config/factoryfx-approved-releases.json. + +## Exact release promotion and safety +1. Download each VST3 ZIP **on CI staging**, not on every user launch. Verify + exact owner-reviewed SHA256, immutable source provenance, redistributable + notices and plugin licensing; never copy private source/activation keys. +2. Run Windows JUCE VST3 host qualification for all four exact binaries: actual + class FUID, plugin description uniqueId, mono/stereo/aux instance, wet DSP, + bypass, multi-instance, states, latency/PDC and GUI lifecycle. + A CI build, an upstream SHA file, or a filename is not qualification. +3. Add one reviewed lock record per **qualified** artifact with + sourceCommit, released ZIP digest, VST3 class ID, actual host UID, + licenseReview=approved, hostQualification=passed and entitlementPolicy. + Include complete applicable notices in config/factoryfx-notices/. + Never invent a SHA, FUID, host UID or approval flag. +4. For *official four-FX packages*, run: + python scripts/factoryfx_release_bundle.py stage --output dist --require four + An incomplete lock fails rather than creating an app-only "four-FX" release. + An experimental app-only FAT remains possible with --require none, but must + never be marketed as a bundled FX production installer. +5. Packager first materializes the entire approved package in a temporary + same-volume directory. ZIP resource, manifest and notice checks run before + one atomic FactoryFX directory rename. Failed staging leaves no half-published + bundle, and the installer/portable ZIP consume the same verified content. +6. On first app launch, Registry rehashes bundled files and validates the + approved manifest **on the scanner worker**. A separately cached plugin + description may skip slow vendor VST3 metadata enumeration only when path, + approved ZIP SHA, native JUCE host UID and product ID match the freshly + validated package. No Factory cache enters the visible catalog until verified. + Audio callback never hashes/scans/opens files/constructs plugins. +7. Show files keep plugin logical identity and state. Each FX must handle + missing/invalid version explicitly; never substitute another vendor plugin + or silently disable the whole audio engine. + +## Release gates +- Fast Python offline tests: 4 supplier discovery, standalone-only stable + skipped, prerelease selected, malicious/duplicate ZIP exclusion, exact-four + identity, failed-second-download atomicity, tampered manifest rejection. +- Node contract tests: Factory-vs-user Vault, cached factory source remains + invisible before independent Registry verification. +- Windows C++ native Registry negative cases, real VST3 load and DSP tests. +- Exact-head installer and portable archive: all four original .vst3 bundles, + their licenses, per-file hashes, offline fresh install, existing mixer upgrade + with safe shutdown, old Show recall, app/user separation. +- ASIO real monitoring with multiple instances, BUS/MAIN wet sends, 44.1/48/96k, + 128/256 frames where supported, rack power/bypass, CPU/xrun observation and + audio-interface FAT. **Physical audio FAT pending until performed**. + +## Cross-PR ownership +This implementation is based on current main. It supersedes stale +Comp-only watcher work in #225 without copying its old engine/GUI baseline. +Do not merge that historical patch on top blindly. Keep installer #443 and +device-retention #445 separate until each passes its own exact-head tests; +reconcile their eventual merged changes before shipping a final four-FX installer. From bbdcc686e9196ef167cbab0ae9ab784c1708f242 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:29:31 +0700 Subject: [PATCH 13/15] fix(factoryfx): isolate optional VST3 failures without hiding healthy modules --- src/FactoryFxRegistry.h | 124 ++++++++++++++++------------- src/PluginCatalog.h | 15 ++-- tests/factory_fx_registry_test.cpp | 40 +++++++++- 3 files changed, 117 insertions(+), 62 deletions(-) diff --git a/src/FactoryFxRegistry.h b/src/FactoryFxRegistry.h index 9eaf21fd7..e653aa14c 100644 --- a/src/FactoryFxRegistry.h +++ b/src/FactoryFxRegistry.h @@ -7,8 +7,8 @@ #include // Control/background thread ONLY. Factory modules are app-managed, never user Vault. -// This parser intentionally rejects an incomplete or modified manifest as a WHOLE: -// a partial load must not make a damaged six-FX package appear healthy. +// Strict mode validates the entire package for release/testing. Runtime mode +// isolates faulty *optional* effects without silencing valid plugins or mixer DSP. namespace armix::factory { struct Candidate @@ -22,6 +22,7 @@ struct Discovery { std::vector candidates; juce::String error; + juce::StringArray warnings; // Runtime only: rejected optional modules, never loadable. bool ok() const noexcept { return error.isEmpty(); } }; @@ -79,7 +80,7 @@ struct Registry final return true; } - static Discovery discover (const juce::File& appRoot) + static Discovery discover (const juce::File& appRoot, bool tolerateUnavailable = false) { Discovery result; auto fail = [&result] (const juce::String& reason) -> Discovery @@ -114,68 +115,81 @@ struct Registry final std::set seen; for (const auto& item : *items) { - if (! item.isObject()) return fail ("invalid plugin entry"); - const auto id = item.getProperty ("productId", {}).toString(); - if (id != "arson-eq" && id != "arson-comp" && id != "arson-verb" && - id != "arson-harmony" && id != "arson-color" && - id != "arsonkupik-enhancer") - return fail ("unapproved product ID"); - if (! seen.insert (id.toStdString()).second) - return fail ("duplicate product ID"); - if (item.getProperty ("licenseReview", {}).toString() != "approved") - return fail (id + ": distribution licence not approved"); - const auto policy = item.getProperty ("entitlementPolicy", {}).toString(); - if (policy != "unrestricted" && policy != "separate-license" && - policy != "factory-entitlement") - return fail (id + ": entitlement status missing"); - if (! hex (item.getProperty ("vst3ClassId", {}).toString(), 32) || - ! hex (item.getProperty ("sourceCommit", {}).toString(), 40) || - ! hex (item.getProperty ("artifactSha256", {}).toString(), 64)) - return fail (id + ": unverified release identity"); - if (! item.hasProperty ("hostUniqueId") || - ! (item.getProperty ("hostUniqueId", {}).isInt() || - item.getProperty ("hostUniqueId", {}).isInt64())) - return fail (id + ": JUCE host UID missing"); - - const auto relative = item.getProperty ("bundleRelativePath", {}).toString(); - if (! safePath (relative) || ! relative.startsWith ("FactoryFX/") || - ! relative.endsWithIgnoreCase (".vst3")) - return fail (id + ": invalid bundle path"); - const auto bundle = appRoot.getChildFile (relative); - if ((! bundle.isDirectory() && ! bundle.existsAsFile()) || - ! contained (appRoot, bundle)) - return fail (id + ": VST3 bundle missing/outside installation"); - - const auto files = item.getProperty ("files", {}); - const auto* fileRows = files.getArray(); - if (fileRows == nullptr || fileRows->isEmpty() || fileRows->size() > 256) - return fail (id + ": no verified VST3 files"); - for (const auto& f : *fileRows) + Candidate candidate; + const auto validate = [&]() -> juce::String + { + if (! item.isObject()) return juce::String ("invalid plugin entry"); + const auto id = item.getProperty ("productId", {}).toString(); + if (id != "arson-eq" && id != "arson-comp" && id != "arson-verb" && + id != "arson-harmony" && id != "arson-color" && + id != "arsonkupik-enhancer") + return juce::String ("unapproved product ID"); + if (! seen.insert (id.toStdString()).second) + return juce::String ("duplicate product ID"); + if (item.getProperty ("licenseReview", {}).toString() != "approved") + return juce::String (id + ": distribution licence not approved"); + const auto policy = item.getProperty ("entitlementPolicy", {}).toString(); + if (policy != "unrestricted" && policy != "separate-license" && + policy != "factory-entitlement") + return juce::String (id + ": entitlement status missing"); + if (! hex (item.getProperty ("vst3ClassId", {}).toString(), 32) || + ! hex (item.getProperty ("sourceCommit", {}).toString(), 40) || + ! hex (item.getProperty ("artifactSha256", {}).toString(), 64)) + return juce::String (id + ": unverified release identity"); + if (! item.hasProperty ("hostUniqueId") || + ! (item.getProperty ("hostUniqueId", {}).isInt() || + item.getProperty ("hostUniqueId", {}).isInt64())) + return juce::String (id + ": JUCE host UID missing"); + + const auto relative = item.getProperty ("bundleRelativePath", {}).toString(); + if (! safePath (relative) || ! relative.startsWith ("FactoryFX/") || + ! relative.endsWithIgnoreCase (".vst3")) + return juce::String (id + ": invalid bundle path"); + const auto bundle = appRoot.getChildFile (relative); + if ((! bundle.isDirectory() && ! bundle.existsAsFile()) || + ! contained (appRoot, bundle)) + return juce::String (id + ": VST3 bundle missing/outside installation"); + + const auto files = item.getProperty ("files", {}); + const auto* fileRows = files.getArray(); + if (fileRows == nullptr || fileRows->isEmpty() || fileRows->size() > 256) + return juce::String (id + ": no verified VST3 files"); + for (const auto& f : *fileRows) + { + const auto name = f.getProperty ("path", {}).toString(); + const auto hash = f.getProperty ("sha256", {}).toString(); + if (! safePath (name) || ! hex (hash, 64)) + return juce::String (id + ": invalid file hash entry"); + const auto binary = name == "." ? bundle : bundle.getChildFile (name); + if (! binary.existsAsFile() || ! contained (bundle.isDirectory() ? bundle : appRoot, binary)) + return juce::String (id + ": bundle resource missing"); + // Disk IO and SHA256 hashing are performed only on scanner worker. + if (! juce::SHA256 (binary).toHexString().equalsIgnoreCase (hash)) + return juce::String (id + ": modified VST3 resource"); + } + candidate = { id, bundle.getFullPathName(), + static_cast (item.getProperty ("hostUniqueId", 0)), + item.getProperty ("artifactSha256", {}).toString() }; + return {}; + }; + const auto rejected = validate(); + if (rejected.isNotEmpty()) { - const auto name = f.getProperty ("path", {}).toString(); - const auto hash = f.getProperty ("sha256", {}).toString(); - if (! safePath (name) || ! hex (hash, 64)) - return fail (id + ": invalid file hash entry"); - const auto binary = name == "." ? bundle : bundle.getChildFile (name); - if (! binary.existsAsFile() || ! contained (bundle.isDirectory() ? bundle : appRoot, binary)) - return fail (id + ": bundle resource missing"); - // Disk IO and SHA256 hashing are performed only on scanner worker. - if (! juce::SHA256 (binary).toHexString().equalsIgnoreCase (hash)) - return fail (id + ": modified VST3 resource"); + if (! tolerateUnavailable) return fail (rejected); + result.warnings.add (rejected); + continue; } - result.candidates.push_back ({ id, bundle.getFullPathName(), - static_cast (item.getProperty ("hostUniqueId", 0)), - item.getProperty ("artifactSha256", {}).toString() }); + result.candidates.push_back (std::move (candidate)); } // Official four-FX packs require the exact reviewed original suppliers. if (distribution == "production-four") { static const std::set required { "arson-eq", "arson-comp", "arson-verb", "arsonkupik-enhancer" }; - if (seen != required) + if (! tolerateUnavailable && seen != required) return fail ("production-four manifest requires EQ, Comp, Verb, KuPik"); } - if (distribution == "production-six" && result.candidates.size() != 6) + if (! tolerateUnavailable && distribution == "production-six" && result.candidates.size() != 6) return fail ("production manifest must contain all six effects"); return result; } diff --git a/src/PluginCatalog.h b/src/PluginCatalog.h index 6d98e0890..6d2e88387 100644 --- a/src/PluginCatalog.h +++ b/src/PluginCatalog.h @@ -220,9 +220,13 @@ class PluginCatalog final juce::StringArray allCandidates; juce::String importErrors; const auto factory = factoryOnly_ - ? armix::factory::Registry::discover (armix::factory::Registry::executableRoot()) + ? armix::factory::Registry::discover (armix::factory::Registry::executableRoot(), true) : armix::factory::Discovery{}; - if (factoryOnly_ && ! factory.ok()) importErrors = factory.error; + if (factoryOnly_) + { + if (! factory.ok()) importErrors = factory.error; + else importErrors = factory.warnings.joinIntoString (" | "); + } // The cache is metadata ONLY. Verified binaries/resources are rehashed // first by Registry on this worker; a cache file cannot authorise FX. juce::var cachedFactory; @@ -332,16 +336,15 @@ class PluginCatalog final owner_.found_.store (static_cast (found.size()), std::memory_order_relaxed); owner_.completed_.store (n + 1, std::memory_order_release); } - if (factoryOnly_ && importErrors.isEmpty()) + if (factoryOnly_ && factory.ok()) { for (const auto& approved : factory.candidates) if (std::none_of (found.begin(), found.end(), [&approved] (const CatalogEntry& e) { return e.factory && e.factoryProductId == approved.productId; })) { - importErrors = approved.productId + ": declared VST3 host UID not found"; - found.clear(); // All-or-nothing factory verification, never partial success. - break; + importErrors << (importErrors.isNotEmpty() ? " | " : "") + << approved.productId << ": VST3 host UID not found"; } } { diff --git a/tests/factory_fx_registry_test.cpp b/tests/factory_fx_registry_test.cpp index 750bd7267..52b9816ab 100644 --- a/tests/factory_fx_registry_test.cpp +++ b/tests/factory_fx_registry_test.cpp @@ -81,11 +81,49 @@ int main() "four-effect production manifest cannot claim one effect")) return 8; + + // A corrupted optional VST3 must be quarantined, not block valid EQ. + const auto secondBundle = root.getChildFile ("FactoryFX/ArSonComp/ArSonComp.vst3"); + if (! secondBundle.getParentDirectory().createDirectory().wasOk() || + ! secondBundle.replaceWithText ("original compressor fixture")) + return 22; + auto two = juce::JSON::parse (original); + auto rowsVar = two.getProperty ("plugins", {}); + auto* rows = rowsVar.getArray(); + if (rows == nullptr || rows->size() != 1) return 23; + auto second = juce::JSON::parse (juce::JSON::toString (rows->getReference (0))); + auto* comp = second.getDynamicObject(); + if (comp == nullptr) return 24; + comp->setProperty ("productId", "arson-comp"); + comp->setProperty ("bundleRelativePath", "FactoryFX/ArSonComp/ArSonComp.vst3"); + comp->setProperty ("hostUniqueId", 2345); + auto filesVar = second.getProperty ("files", {}); + auto* fileRows = filesVar.getArray(); + if (fileRows == nullptr || fileRows->isEmpty()) return 25; + fileRows->getReference (0).getDynamicObject()->setProperty ( + "sha256", juce::SHA256 (secondBundle).toHexString()); + rows->add (second); + const auto twoManifest = juce::JSON::toString (two); + manifest.replaceWithText (twoManifest); + secondBundle.replaceWithText ("damaged compressor"); + scan = armix::factory::Registry::discover (root); + if (! check (! scan.ok() && scan.candidates.empty(), + "strict package gate rejects any modified effect")) return 26; + scan = armix::factory::Registry::discover (root, true); + if (! check (scan.ok() && scan.candidates.size() == 1 && + scan.candidates.front().productId == "arson-eq" && + ! scan.warnings.isEmpty(), + "runtime isolates damaged compressor and preserves verified EQ")) return 27; + secondBundle.replaceWithText ("original compressor fixture"); + scan = armix::factory::Registry::discover (root, true); + if (! check (scan.ok() && scan.candidates.size() == 2 && + scan.warnings.isEmpty(), "valid optional effects all load")) return 28; + manifest.deleteFile(); scan = armix::factory::Registry::discover (root); if (! check (! scan.ok() && scan.candidates.empty(), "missing manifest rejected")) return 7; - std::cout << "FactoryFX registry: valid package + 7 negative gates passed\n"; + std::cout << "FactoryFX registry: valid package + isolated optional VST3 regression passed\n"; return 0; } From 201011f1ebb18b31132b4559293a6b3aa421c6c1 Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:31:24 +0700 Subject: [PATCH 14/15] feat(factoryfx): stage approved VST3 bonuses independently; preserve core mixer on missing assets --- .github/workflows/p1-windows.yml | 2 +- ...TORYFX_FOUR_VST3_RELEASE_GATES_20261108.md | 27 +-- scripts/factoryfx_release_bundle.py | 158 +++++++++++++----- .../tests/test_factoryfx_release_bundle.py | 53 ++++++ scripts/verify_native_windows_artifact.ps1 | 5 +- 5 files changed, 186 insertions(+), 59 deletions(-) diff --git a/.github/workflows/p1-windows.yml b/.github/workflows/p1-windows.yml index 4547be3ee..0292480ca 100644 --- a/.github/workflows/p1-windows.yml +++ b/.github/workflows/p1-windows.yml @@ -240,7 +240,7 @@ jobs: if: ${{ github.event_name == 'workflow_dispatch' && inputs.package_fat == true }} shell: pwsh run: | - python scripts/factoryfx_release_bundle.py stage --lock config/factoryfx-approved-releases.json --output dist + python scripts/factoryfx_release_bundle.py stage --lock config/factoryfx-approved-releases.json --output dist --best-effort if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE } - name: Independently verify release ZIP and embedded GUI/engine before upload if: ${{ github.event_name == 'workflow_dispatch' && inputs.package_fat == true }} diff --git a/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md b/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md index 8ecafab8a..328332745 100644 --- a/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md +++ b/docs/FACTORYFX_FOUR_VST3_RELEASE_GATES_20261108.md @@ -1,8 +1,10 @@ # FXF4 — Four first-party VST3 FactoryFX release path (2026-11-08) ## Product outcome -The first public four-FX ArSonMix package must contain **ArSonEQ, ArSonComp, -ArSonVerb and ArSonKuPik Enhancer** in both the portable ZIP and Inno installer. +ArSonMix is **primarily a mixer with its native built-in FX**. Extra VST3 +modules are optional bonuses, never a dependency for shipping or running it. +Bundle every separately approved and obtainable ArSonEQ, ArSonComp, ArSonVerb +or ArSonKuPik VST3. Zero to four extras is allowed; aim for at least one. The native Parametric EQ already compiled into ArSonMix is a separate built-in insert and remains available irrespective of external VST3 packaging. @@ -36,11 +38,14 @@ config/factoryfx-approved-releases.json. licenseReview=approved, hostQualification=passed and entitlementPolicy. Include complete applicable notices in config/factoryfx-notices/. Never invent a SHA, FUID, host UID or approval flag. -4. For *official four-FX packages*, run: - python scripts/factoryfx_release_bundle.py stage --output dist --require four - An incomplete lock fails rather than creating an app-only "four-FX" release. - An experimental app-only FAT remains possible with --require none, but must - never be marketed as a bundled FX production installer. +4. Normal mixer packaging uses: + python scripts/factoryfx_release_bundle.py stage --output dist --best-effort + Each approved module is staged independently. Missing ZIP, invalid archive, + checksum mismatch or absent notice skips ONLY that bonus, with a separate + FACTORYFX_STAGE_REPORT.json recording included/omitted modules. The native + mixer and its built-in EQ are still shipped, even if none is available. + Separate strict qualification may use `--require four` without best-effort. + Never advertise four shipped VST3 unless all four are in the verified ZIP. 5. Packager first materializes the entire approved package in a temporary same-volume directory. ZIP resource, manifest and notice checks run before one atomic FactoryFX directory rename. Failed staging leaves no half-published @@ -51,7 +56,9 @@ config/factoryfx-approved-releases.json. approved ZIP SHA, native JUCE host UID and product ID match the freshly validated package. No Factory cache enters the visible catalog until verified. Audio callback never hashes/scans/opens files/constructs plugins. -7. Show files keep plugin logical identity and state. Each FX must handle +7. Runtime quarantines a corrupt/missing/UID-mismatched optional effect only; + healthy approved FX remain available. The native EQ and mixer must stay live. +8. Show files keep plugin logical identity and state. Each FX must handle missing/invalid version explicitly; never substitute another vendor plugin or silently disable the whole audio engine. @@ -62,8 +69,8 @@ config/factoryfx-approved-releases.json. - Node contract tests: Factory-vs-user Vault, cached factory source remains invisible before independent Registry verification. - Windows C++ native Registry negative cases, real VST3 load and DSP tests. -- Exact-head installer and portable archive: all four original .vst3 bundles, - their licenses, per-file hashes, offline fresh install, existing mixer upgrade +- Exact-head installer and portable archive: only successfully attested .vst3 bundles, + their licenses, per-file hashes, accurate omission report, offline fresh install, existing mixer upgrade with safe shutdown, old Show recall, app/user separation. - ASIO real monitoring with multiple instances, BUS/MAIN wet sends, 44.1/48/96k, 128/256 frames where supported, rack power/bypass, CPU/xrun observation and diff --git a/scripts/factoryfx_release_bundle.py b/scripts/factoryfx_release_bundle.py index ceecc6e58..b8301e9c2 100644 --- a/scripts/factoryfx_release_bundle.py +++ b/scripts/factoryfx_release_bundle.py @@ -1,8 +1,8 @@ #!/usr/bin/env python3 -"""Fail-closed ArSonMix Factory VST3 release staging. Python stdlib only. +"""Verified optional ArSonMix Factory VST3 release staging. Python stdlib only. -A reviewed lock is the ONLY authority to ship a binary. Upstream latest-release -discovery cannot change this lock or bypass entitlement/host qualification. +A reviewed lock is the ONLY authority to ship a binary. Optional per-plugin +failure never blocks the mixer, but NEVER bypasses entitlement/host approval. The native JUCE registry independently rehashes every staged resource off RT. """ import argparse @@ -154,7 +154,7 @@ def zip_members(z, bundle): return chosen -def stage(plugins, output, notices): +def stage(plugins, output, notices, best_effort=False): """Build the WHOLE factory off to the side; publish only after full verify. A partial download, invalid ZIP, bad notice or failed integrity check must @@ -166,7 +166,7 @@ def stage(plugins, output, notices): destination = output / "FactoryFX" if destination.exists() or destination.is_symlink(): fail("staging must start with clean FactoryFX destination") - if not plugins: + if not plugins and not best_effort: print("FACTORYFX: no approved plugins; app-only engineering package unchanged") return with tempfile.TemporaryDirectory(prefix=".factoryfx-incoming-", dir=output) as work: @@ -175,48 +175,72 @@ def stage(plugins, output, notices): staging.mkdir() factory = staging / "FactoryFX" rows = [] + omitted = [] for p in plugins: pid = p["productId"] - _, display, bundle, category = OWNED[pid] - notice = notices / (pid + ".txt") - if not notice.is_file() or not notice.read_text(encoding="utf-8").strip(): - fail(pid + ": reviewed redistribution/EULA notice missing") - archive = temp / (pid + ".zip") - download_release(p, archive) - target = factory / display / bundle - target.mkdir(parents=True, exist_ok=False) - with zipfile.ZipFile(archive) as z: - for info, relative in zip_members(z, bundle): - path = target.joinpath(*relative.split("/")) - path.parent.mkdir(parents=True, exist_ok=True) - with z.open(info) as src, open(path, "wb") as dest: - shutil.copyfileobj(src, dest, 1024 * 1024) - files = [{"path": f.relative_to(target).as_posix(), "sha256": sha256(f)} - for f in sorted(target.rglob("*")) if f.is_file()] - notice_to = factory / "licenses" / (pid + ".txt") - notice_to.parent.mkdir(parents=True, exist_ok=True) - shutil.copyfile(notice, notice_to) - rows.append({ - "productId": pid, "displayName": display, "category": category, - "pluginVersion": p["version"], "sourceRepo": p["sourceRepo"], - "sourceCommit": p["sourceCommit"], "artifactSha256": p["artifactSha256"].lower(), - "bundleRelativePath": "FactoryFX/" + display + "/" + bundle, - "vst3ClassId": p["vst3ClassId"].upper(), "hostUniqueId": p["hostUniqueId"], - "licenseReview": "approved", "entitlementPolicy": p["entitlementPolicy"], - "notices": ["FactoryFX/licenses/" + pid + ".txt"], "files": files, - }) - manifest = { - "schemaVersion": 1, "platform": "windows-x64", "hostFormat": "VST3", - "distribution": distribution_for(plugins), "plugins": rows, + try: + _, display, bundle, category = OWNED[pid] + notice = notices / (pid + ".txt") + if not notice.is_file() or not notice.read_text(encoding="utf-8").strip(): + fail(pid + ": reviewed redistribution/EULA notice missing") + archive = temp / (pid + ".zip") + download_release(p, archive) + target = factory / display / bundle + target.mkdir(parents=True, exist_ok=False) + with zipfile.ZipFile(archive) as z: + for info, relative in zip_members(z, bundle): + path = target.joinpath(*relative.split("/")) + path.parent.mkdir(parents=True, exist_ok=True) + with z.open(info) as src, open(path, "wb") as dest: + shutil.copyfileobj(src, dest, 1024 * 1024) + files = [{"path": f.relative_to(target).as_posix(), "sha256": sha256(f)} + for f in sorted(target.rglob("*")) if f.is_file()] + notice_to = factory / "licenses" / (pid + ".txt") + notice_to.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(notice, notice_to) + rows.append({ + "productId": pid, "displayName": display, "category": category, + "pluginVersion": p["version"], "sourceRepo": p["sourceRepo"], + "sourceCommit": p["sourceCommit"], "artifactSha256": p["artifactSha256"].lower(), + "bundleRelativePath": "FactoryFX/" + display + "/" + bundle, + "vst3ClassId": p["vst3ClassId"].upper(), "hostUniqueId": p["hostUniqueId"], + "licenseReview": "approved", "entitlementPolicy": p["entitlementPolicy"], + "notices": ["FactoryFX/licenses/" + pid + ".txt"], "files": files, + }) + except (ValueError, OSError, urllib.error.URLError, zipfile.BadZipFile) as error: + if not best_effort: + raise + # A failed supplier cannot leave a broken module in the final bundle. + shutil.rmtree(factory / OWNED[pid][1], ignore_errors=True) + (factory / "licenses" / (pid + ".txt")).unlink(missing_ok=True) + omitted.append({"productId": pid, "reason": type(error).__name__}) + print("FACTORYFX OPTIONAL SKIPPED: " + pid + " (" + type(error).__name__ + ")") + accepted_ids = {row["productId"] for row in rows} + accepted = [entry for entry in plugins if entry["productId"] in accepted_ids] + if rows: + manifest = { + "schemaVersion": 1, "platform": "windows-x64", "hostFormat": "VST3", + "distribution": distribution_for(accepted), "plugins": rows, + } + (factory / "factoryfx-manifest.json").write_text( + json.dumps(manifest, indent=2) + "\n", encoding="utf-8") + # Verify exact optional subset BEFORE publishing the completed bundle. + verify(accepted, staging, notices) + if destination.exists() or destination.is_symlink(): + fail("concurrent FactoryFX staging detected") + factory.rename(destination) + if best_effort: + report = { + "schemaVersion": 1, "mode": "best-effort", + "included": [{"productId": row["productId"], + "artifactSha256": row["artifactSha256"]} for row in rows], + "omitted": omitted, } - (factory / "factoryfx-manifest.json").write_text( - json.dumps(manifest, indent=2) + "\n", encoding="utf-8") - # Verify staging BEFORE revealing it to runtime, packaging, or installer. - verify(plugins, staging, notices) - if destination.exists() or destination.is_symlink(): - fail("concurrent FactoryFX staging detected") - factory.rename(destination) - print("FACTORYFX staged and verified: " + ", ".join(x["productId"] for x in rows)) + (output / "FACTORYFX_STAGE_REPORT.json").write_text( + json.dumps(report, indent=2) + "\n", encoding="utf-8") + print("FACTORYFX staged and verified: " + + (", ".join(x["productId"] for x in rows) if rows else "no optional VST3; mixer unchanged")) + def verify(plugins, output, notices): factory = output / "FactoryFX" @@ -275,6 +299,42 @@ def verify(plugins, output, notices): fail("FactoryFX untracked/extra resource or user content found") +def read_best_effort_report(plugins, output): + """Independently constrain a partial staged set to the immutable reviewed lock.""" + path = Path(output) / "FACTORYFX_STAGE_REPORT.json" + report = json.loads(path.read_text(encoding="utf-8")) + if (not isinstance(report, dict) or set(report) != + {"schemaVersion", "mode", "included", "omitted"} or + report["schemaVersion"] != 1 or report["mode"] != "best-effort" or + not isinstance(report["included"], list) or + not isinstance(report["omitted"], list)): + fail("invalid optional FactoryFX stage report") + locked = {p["productId"]: p for p in plugins} + accepted_ids = [] + for row in report["included"]: + if (not isinstance(row, dict) or set(row) != + {"productId", "artifactSha256"} or + row["productId"] not in locked or + row["artifactSha256"] != locked[row["productId"]]["artifactSha256"].lower()): + fail("unreviewed FactoryFX stage report inclusion") + accepted_ids.append(row["productId"]) + omitted_ids = [] + for row in report["omitted"]: + if (not isinstance(row, dict) or set(row) != {"productId", "reason"} or + row["productId"] not in locked or + not isinstance(row["reason"], str) or + not re.fullmatch(r"[A-Za-z]{3,40}", row["reason"])): + fail("invalid optional FactoryFX omission") + omitted_ids.append(row["productId"]) + expected_ids = [p["productId"] for p in plugins] + if (accepted_ids != [pid for pid in expected_ids if pid in accepted_ids] or + omitted_ids != [pid for pid in expected_ids if pid in omitted_ids] or + len(accepted_ids) + len(omitted_ids) != len(expected_ids) or + len(set(accepted_ids + omitted_ids)) != len(expected_ids)): + fail("FactoryFX stage report does not account for every approved module") + return [locked[pid] for pid in accepted_ids] + + def main(): parser = argparse.ArgumentParser() parser.add_argument("action", choices=["stage", "verify"]) @@ -282,8 +342,12 @@ def main(): parser.add_argument("--notices", default="config/factoryfx-notices") parser.add_argument("--output", default="dist") parser.add_argument("--require", choices=["none", "factory", "four", "six"], default="none") + parser.add_argument("--best-effort", action="store_true", + help="Include each approved, retrievable plugin; never block core mixer") args = parser.parse_args() plugins = read_lock(args.lock) + if args.best_effort and args.require != "none": + fail("--best-effort cannot bypass an explicit --require gate") if args.require == "factory" and not plugins: fail("Factory FX required but no approved release") if args.require == "four" and distribution_for(plugins) != "production-four": @@ -291,9 +355,11 @@ def main(): if args.require == "six" and distribution_for(plugins) != "production-six": fail("Six-FX release requires all six approved effects") if args.action == "stage": - stage(plugins, Path(args.output), Path(args.notices)) + stage(plugins, Path(args.output), Path(args.notices), args.best_effort) else: - verify(plugins, Path(args.output), Path(args.notices)) + accepted = (read_best_effort_report(plugins, Path(args.output)) + if args.best_effort else plugins) + verify(accepted, Path(args.output), Path(args.notices)) if __name__ == "__main__": diff --git a/scripts/tests/test_factoryfx_release_bundle.py b/scripts/tests/test_factoryfx_release_bundle.py index f939fd876..904de481b 100644 --- a/scripts/tests/test_factoryfx_release_bundle.py +++ b/scripts/tests/test_factoryfx_release_bundle.py @@ -172,6 +172,59 @@ def fake_download(release, target): self.assertFalse((self.output / "FactoryFX").exists()) self.assertFalse(list(self.output.glob(".factoryfx-incoming-*"))) + + def test_optional_bundle_skips_broken_plugin_and_keeps_verified_eq(self): + other = dict(self.approved, productId="arson-verb", + sourceRepo="masarray/arsonverb", + assetName="ArSonVerb-Windows-x64-VST3.zip") + (self.notices / "arson-verb.txt").write_text( + "Reviewed optional Reverb", encoding="utf-8") + self.save_lock(self.approved, other) + + def try_download(item, target): + if item["productId"] == "arson-verb": + raise ValueError("upstream artifact is not available") + shutil.copyfile(self.archive, target) + + with patch.object(bundle, "download_release", side_effect=try_download): + bundle.stage(bundle.read_lock(self.lock), self.output, self.notices, + best_effort=True) + accepted = bundle.read_best_effort_report(bundle.read_lock(self.lock), self.output) + self.assertEqual([p["productId"] for p in accepted], ["arson-eq"]) + bundle.verify(accepted, self.output, self.notices) + manifest = json.loads( + (self.output / "FactoryFX/factoryfx-manifest.json").read_text()) + self.assertEqual(manifest["distribution"], "engineering-partial") + self.assertEqual(len(manifest["plugins"]), 1) + self.assertFalse(list(self.output.glob(".factoryfx-incoming-*"))) + self.assertFalse((self.output / "FactoryFX/ArSonVerb").exists()) + + def test_optional_bundle_all_unavailable_does_not_block_mixer(self): + self.save_lock(self.approved) + with patch.object(bundle, "download_release", side_effect=OSError("offline")): + bundle.stage(bundle.read_lock(self.lock), self.output, self.notices, + best_effort=True) + self.assertFalse((self.output / "FactoryFX").exists()) + accepted = bundle.read_best_effort_report(bundle.read_lock(self.lock), self.output) + self.assertEqual(accepted, []) + bundle.verify(accepted, self.output, self.notices) + report = json.loads((self.output / "FACTORYFX_STAGE_REPORT.json").read_text()) + self.assertEqual(report["omitted"][0]["productId"], "arson-eq") + report["included"] = [{"productId": "unapproved-module", + "artifactSha256": "a" * 64}] + (self.output / "FACTORYFX_STAGE_REPORT.json").write_text(json.dumps(report)) + with self.assertRaises(ValueError): + bundle.read_best_effort_report(bundle.read_lock(self.lock), self.output) + + def test_optional_bundle_empty_reviewed_lock_is_valid_core_only(self): + self.save_lock() + bundle.stage(bundle.read_lock(self.lock), self.output, self.notices, + best_effort=True) + self.assertFalse((self.output / "FactoryFX").exists()) + self.assertEqual( + bundle.read_best_effort_report(bundle.read_lock(self.lock), self.output), + []) + def test_production_names_are_exact_not_count_only(self): refs = [dict(self.approved, productId=pid) for pid in ("arson-eq", "arson-comp", "arson-harmony", "arson-color")] diff --git a/scripts/verify_native_windows_artifact.ps1 b/scripts/verify_native_windows_artifact.ps1 index 8f20d7c3b..37c54134b 100644 --- a/scripts/verify_native_windows_artifact.ps1 +++ b/scripts/verify_native_windows_artifact.ps1 @@ -13,7 +13,8 @@ $expected = @( "README.md", "portable_mode.txt", "collect_hardware_fat_windows.ps1", - "m3e_fat_evidence_gate.mjs" + "m3e_fat_evidence_gate.mjs", + "FACTORYFX_STAGE_REPORT.json" ) foreach ($name in $expected) { if (-not (Test-Path -LiteralPath (Join-Path $OutputDir $name) -PathType Leaf)) { @@ -22,7 +23,7 @@ foreach ($name in $expected) { } # Verify FactoryFX only when an exact reviewed lock explicitly authorizes it. # App-only engineering ZIPs remain unchanged; a missing approved module fails. -& python scripts/factoryfx_release_bundle.py verify --lock config/factoryfx-approved-releases.json --output $OutputDir +& python scripts/factoryfx_release_bundle.py verify --lock config/factoryfx-approved-releases.json --output $OutputDir --best-effort if ($LASTEXITCODE -ne 0) { throw "FactoryFX resource, manifest or licence gate failed" } $factoryPath = Join-Path $OutputDir "FactoryFX" $topDirs = @(Get-ChildItem -LiteralPath $OutputDir -Directory | ForEach-Object Name) From c7612669fe5f3328915e4457d9fbf3ea62582dde Mon Sep 17 00:00:00 2001 From: Ari Sulistiono Date: Sun, 8 Nov 2026 06:32:53 +0700 Subject: [PATCH 15/15] fix(factoryfx): remove undefined UI snapshot cache reference; keep cache private to persistence --- src/PluginCatalog.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/PluginCatalog.h b/src/PluginCatalog.h index 6d2e88387..6d47fc3c3 100644 --- a/src/PluginCatalog.h +++ b/src/PluginCatalog.h @@ -194,7 +194,6 @@ class PluginCatalog final for (const auto& entry : entries_) list.add (entry.toVar()); o->setProperty ("items", juce::var (list)); - o->setProperty ("verifiedFactory", juce::var (verifiedFactory)); o->setProperty ("scanning", busy()); o->setProperty ("message", scanMessage_); o->setProperty ("count", static_cast (entries_.size()));