Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

feat(gates): a tier above experimental has to be earned

esengineebada52c5033
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0b40bea12..6c45f3397 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -89,6 +89,32 @@ published separately; it ships inside the editor.
puts the continuation on the microtask queue, where no frame can run: five runs
now agree to 4e-5, where before they scattered.
+- **`check-tier-bar` — a tier above `experimental` has to be earned, and now
+ something asks.** `check-subsystem-tiers` holds the table against the tags: a
+ verdict and the code carrying it are one answer. Nothing could say whether the
+ verdict was EARNED, so a promotion was a judgement made once, argued in prose
+ and never re-asked — two rows said only "the runtime surface has not been read
+ for a tier yet", which is a note to self.
+
+ The bar is the one `check-freeze-bar` already applies to a `@public` symbol,
+ asked of the entry a subsystem publishes its verdict on: documented, tested,
+ and — for values — called by a golden project. **It is a floor, not a
+ promotion.** Clearing it makes a tier permissible; whether the evidence is
+ BROAD enough to promise on stays a judgement, in `why`. What it removes is the
+ other case: a claim that could not have been earned, made because nobody had a
+ way to ask.
+
+ It is calibrated rather than invented: **all six `public` subsystems clear it**.
+ Ten of the sixteen above experimental do; the six that do not were published
+ before the bar and carry what they still owe, each line checked to still be
+ true, so the day a gap closes the gate says so instead of the entry becoming a
+ lie. Sabotage-verified three ways — promoting an unearned row, dropping a debt
+ that is still owed, and claiming one that is not.
+
+ The three evidences moved to `tools/lib/apiEvidence.mjs`, since two bars now
+ ask for them and two copies would be two bars under one name; `check-freeze-bar`
+ prints byte-identically across the move.
+
- **`check-verifier-owners` — a checker nobody runs is a checker that rots.**
`check-release-gate` holds one direction: every exit criterion has something
answering it. Nothing held the other, and `verify:aot` fell through it — a
diff --git a/tools/check-freeze-bar.mjs b/tools/check-freeze-bar.mjs
index 5270199da..1a8b184e5 100644
--- a/tools/check-freeze-bar.mjs
+++ b/tools/check-freeze-bar.mjs
@@ -18,7 +18,7 @@
* already checks its shape everywhere it is used)
*
* A symbol that cannot meet the bar and should still be frozen goes in
- * {@link EXEMPT} with a reason, the same bargain goldenProjects strikes: the
+ * {@link BLIND} with a reason, the same bargain goldenProjects strikes: the
* hole stays visible instead of passing for coverage.
*
* A symbol that SHOULD be frozen and cannot be yet goes in {@link BLOCKED}. That
@@ -33,7 +33,9 @@
*/
import { readFileSync, readdirSync, existsSync } from 'node:fs';
import { join, relative } from 'node:path';
-import { ROOT, SDK, ETC, ts, ENTRIES, createSdkProgram, leadingDoc, docProseLines } from './lib/sdkProgram.mjs';
+import { ROOT, SDK, ETC, ts, ENTRIES, createSdkProgram } from './lib/sdkProgram.mjs';
+import { VALUE_KINDS, BLIND, hasDocProse, testedIdentifiers, exercisedByGolden, declarationsOf }
+ from './lib/apiEvidence.mjs';
import { parseSnapshot } from './lib/apiSnapshot.mjs';
import { GOLDEN, projectDir } from './goldenProjects.mjs';
@@ -43,29 +45,9 @@ import { GOLDEN, projectDir } from './goldenProjects.mjs';
* its name and no import list can show it — while every golden project runs one
* every frame. The criterion is blind to them, not unmet by them.
*/
-const RECEIVED = 'received from a declared parameter, never imported — golden projects run it, no import list names it';
-const HANDED_BACK = 'answered by a frozen factory, never imported — a game names the factory, not this';
-export const EXEMPT = {
- InputMap: HANDED_BACK,
- // Same blindness, from the other direction: the map's rebind scan builds one
- // when a player binds a mouse button, so a certified game runs it without any
- // import list ever naming it.
- MouseButton: 'built by InputMap\'s rebind scan on the game\'s behalf — run by a golden project, named by none',
- // Same shape of blindness: the engine maintains this one from Parent, so a
- // game reads it and every golden project's layout walks it every frame, but
- // nothing imports the name.
- Children: 'engine-maintained from Parent — walked every frame, named in no import list',
- CommandsInstance: RECEIVED,
- EntityCommands: RECEIVED,
- EventReaderInstance: RECEIVED,
- EventWriterInstance: RECEIVED,
- QueryInstance: RECEIVED,
- RemovedQueryInstance: RECEIVED,
- ResMutInstance: RECEIVED,
-};
/**
- * Freezes that were decided on and refused. Unlike {@link EXEMPT} these are NOT
+ * Freezes that were decided on and refused. Unlike {@link BLIND} these are NOT
* frozen: the entry records that the gap is in the corpus rather than the API.
* `needs` is the bar's own wording, so the check can confirm the symbol still
* falls short for that reason and not some other.
@@ -87,9 +69,6 @@ export const BLOCKED = {
// BREADTH of the promise is not a missing criterion. The @beta tag records that,
// at the declaration, with its reason.
-/** Snapshot kinds that a game calls at runtime; the rest are shapes. */
-const VALUE_KINDS = new Set(['class', 'enum', 'function', 'const', 'value', 'namespace']);
-
// ---------------------------------------------------------------------------
// What the snapshots froze
// ---------------------------------------------------------------------------
@@ -107,69 +86,6 @@ function frozenSymbols() {
return out;
}
-// ---------------------------------------------------------------------------
-// Documented
-// ---------------------------------------------------------------------------
-
-/** A leading doc block carrying at least one line that is not a tag. */
-function hasDocProse(decl) {
- return docProseLines(leadingDoc(decl)).length > 0;
-}
-
-// ---------------------------------------------------------------------------
-// Tested / exercised
-// ---------------------------------------------------------------------------
-
-function walk(dir, onFile, skip) {
- let entries;
- try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
- for (const e of entries) {
- const p = join(dir, e.name);
- if (skip(p, e.name)) continue;
- if (e.isDirectory()) walk(p, onFile, skip);
- else onFile(p);
- }
-}
-
-/** Every identifier named anywhere in the SDK's tests. */
-function testedIdentifiers() {
- const seen = new Set();
- const skip = (p, name) => name === 'node_modules' || name === 'dist';
- walk(join(SDK, 'src'), collect, skip);
- walk(join(SDK, 'tests'), collect, skip);
- function collect(p) {
- if (!/\.test\.ts$/.test(p)) return;
- for (const id of readFileSync(p, 'utf8').match(/[A-Za-z_$][\w$]*/g) ?? []) seen.add(id);
- }
- return seen;
-}
-
-// Every entry, not just the root one: the SDK ships nine, and a symbol reached
-// through `esengine/spine` is as exercised as one reached through `esengine`.
-const ESENGINE_IMPORT = /import\s+(?:type\s+)?\{([^}]*)\}\s*from\s*['"]esengine(?:\/[^'"]+)?['"]/g;
-
-/** Symbols each golden project imports from an `esengine` entry, as `name -> [projectId]`. */
-function exercisedByGolden() {
- const out = new Map();
- for (const g of GOLDEN) {
- const dir = projectDir(g.id);
- if (!existsSync(dir)) continue;
- walk(dir, (p) => {
- if (!/\.ts$/.test(p) || /\.d\.ts$/.test(p)) return;
- const src = readFileSync(p, 'utf8');
- for (const m of src.matchAll(ESENGINE_IMPORT)) {
- for (const raw of m[1].split(',')) {
- const name = raw.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0].trim();
- if (!name) continue;
- if (!out.has(name)) out.set(name, new Set());
- out.get(name).add(g.id);
- }
- }
- }, (p, name) => name === '.esengine' || name === 'node_modules' || name === 'dist');
- }
- return out;
-}
-
// ---------------------------------------------------------------------------
// Report
// ---------------------------------------------------------------------------
@@ -214,18 +130,7 @@ const kinds = allSymbols();
const wanted = new Set([...frozen.keys(), ...(asked.length ? [] : Object.keys(BLOCKED))]);
const { program, checker } = createSdkProgram();
-const declarations = new Map();
-for (const entryPath of Object.values(ENTRIES)) {
- const sourceFile = program.getSourceFile(join(SDK, entryPath));
- const moduleSymbol = sourceFile && checker.getSymbolAtLocation(sourceFile);
- if (!moduleSymbol) continue;
- for (const symbol of checker.getExportsOfModule(moduleSymbol)) {
- if (declarations.has(symbol.name) || !wanted.has(symbol.name)) continue;
- const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
- const decl = resolved.declarations?.[0];
- if (decl) declarations.set(symbol.name, decl);
- }
-}
+const declarations = declarationsOf(wanted, program, checker);
const tested = testedIdentifiers();
const exercised = exercisedByGolden();
@@ -243,14 +148,14 @@ function shortfall(name, kind) {
const failures = [];
for (const [name, kind] of [...frozen].sort()) {
- const excuse = EXEMPT[name];
+ const excuse = BLIND[name];
const missing = shortfall(name, kind);
if (missing === null) {
failures.push({ name, say: 'is @public in a snapshot but resolves to no declaration' });
continue;
}
if (!missing.length) {
- if (excuse) failures.push({ name, say: `meets the bar but is still listed in EXEMPT — drop the excuse` });
+ if (excuse) failures.push({ name, say: `meets the bar but is still listed in BLIND — drop the excuse` });
continue;
}
if (excuse) continue;
@@ -261,7 +166,7 @@ for (const [name, kind] of [...frozen].sort()) {
// Not in --why: that mode is asked about a chosen few, so every other exemption
// would read as an inconsistency it did not ask about.
if (!asked.length) {
- for (const [name, why] of Object.entries(EXEMPT)) {
+ for (const [name, why] of Object.entries(BLIND)) {
if (!frozen.has(name)) failures.push({ name, say: `is exempt from the freeze bar but is not @public — ${why}` });
}
}
@@ -310,9 +215,9 @@ if (asked.length) {
const values = [...frozen].filter(([, k]) => VALUE_KINDS.has(k)).length;
if (failures.length === 0) {
- const exempt = Object.keys(EXEMPT).length;
+ const exempt = Object.keys(BLIND).length;
console.log(`check-freeze-bar: ${frozen.size} @public symbol(s) (${values} called at runtime) — documented, tested, exercised.`);
- for (const [name, why] of Object.entries(EXEMPT)) console.log(` exempt: ${name} — ${why}`);
+ for (const [name, why] of Object.entries(BLIND)) console.log(` exempt: ${name} — ${why}`);
if (exempt) console.log(` ${exempt} exemption(s) — each is a symbol the corpus does not hold up.`);
if (blocked.length) {
console.log(` ${blocked.length} freeze(s) decided and still refused — node tools/check-freeze-bar.mjs --blocked`);
diff --git a/tools/check-tier-bar.mjs b/tools/check-tier-bar.mjs
new file mode 100644
index 000000000..f0da0bd54
--- /dev/null
+++ b/tools/check-tier-bar.mjs
@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
+/**
+ * @file check-tier-bar.mjs — what a subsystem must have before it may leave
+ * `experimental`.
+ *
+ * `check-subsystem-tiers` holds the table against the tags: a verdict and the
+ * code that carries it are one answer. It cannot say whether the verdict was
+ * EARNED, and nothing could — so a promotion was a judgement made once, argued
+ * in prose, and never re-asked. Two rows said only "the runtime surface has not
+ * been read for a tier yet", which is a note to self, not a criterion.
+ *
+ * The bar is the one `check-freeze-bar` already applies to a @public symbol,
+ * asked of the `entry` a subsystem publishes its verdict on:
+ * documented the contract is readable without the implementation
+ * tested something pins the shape
+ * exercised a golden project imports it (values only — a type carries no
+ * runtime behaviour a package can certify)
+ *
+ * **It is a floor, not a promotion.** Clearing it makes a tier permissible;
+ * whether the evidence is BROAD enough to promise on is a judgement, and stays
+ * in `why`. What the bar removes is the other case — a claim that could not have
+ * been earned, made because nobody had a way to ask.
+ *
+ * Calibration: all six `public` subsystems clear it, which is how we know it is
+ * the bar already in force rather than a new one invented here.
+ *
+ * A row published before this existed and still short goes in {@link OWED} with
+ * what it lacks, checked to STILL lack it — so the day the gap closes the gate
+ * says so instead of the entry quietly becoming a lie.
+ *
+ * node tools/check-tier-bar.mjs
+ * node tools/check-tier-bar.mjs --report every subsystem and its shortfall
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { ETC, ENTRIES } from './lib/sdkProgram.mjs';
+import { parseSnapshot } from './lib/apiSnapshot.mjs';
+import {
+ VALUE_KINDS, BLIND, hasDocProse, testedIdentifiers, exercisedByGolden,
+ declarationsOf, createSdkProgram,
+} from './lib/apiEvidence.mjs';
+import { SUBSYSTEMS } from './apiSubsystems.mjs';
+
+/**
+ * Rows that claimed a tier before the bar was asked, and what each still owes.
+ * `needs` is the bar's own wording; an entry whose row now clears is an error,
+ * because a list of debts nobody pays down reads like a list of exemptions.
+ */
+const OWED = {
+ 'input-raw': ['TouchPoint is named by no SDK test'],
+ scene: [
+ 'SceneConfig is named by no SDK test',
+ 'transitionTo is named by no SDK test',
+ 'SceneManagerState is called by no golden project',
+ ],
+ prefab: [
+ 'Prefabs is named by no SDK test',
+ 'SpawnOverride is named by no SDK test',
+ 'PrefabServer is called by no golden project',
+ ],
+ assets: ['AssetsData is named by no SDK test'],
+ camera: ['CameraData is named by no SDK test'],
+ animation: ['SpriteAnimator is called by no golden project'],
+};
+
+const REPORT = process.argv.includes('--report');
+
+/** Every exported symbol's snapshot kind, so a type is not asked to be called. */
+function kinds() {
+ const out = new Map();
+ for (const entryName of Object.keys(ENTRIES)) {
+ const file = join(ETC, `${entryName}.api.md`);
+ if (!existsSync(file)) continue;
+ for (const [name, s] of parseSnapshot(readFileSync(file, 'utf8'))) {
+ if (!out.has(name)) out.set(name, s.kind);
+ }
+ }
+ return out;
+}
+
+const kindOf = kinds();
+const tested = testedIdentifiers();
+const exercised = exercisedByGolden();
+const wanted = new Set(SUBSYSTEMS.flatMap((s) => s.entry ?? []));
+const { program, checker } = createSdkProgram();
+const declarations = declarationsOf(wanted, program, checker);
+
+/** What the bar still wants from a subsystem, in its own wording. */
+function shortfall(sub) {
+ const missing = [];
+ for (const name of sub.entry ?? []) {
+ if (BLIND[name]) continue;
+ const decl = declarations.get(name);
+ // Unresolvable is "cannot tell", and check-subsystem-tiers already fails
+ // a verdict resting on a name no entry exports. Not counted twice here.
+ if (!decl) continue;
+ if (!hasDocProse(decl)) missing.push(`${name} carries no doc prose`);
+ if (!tested.has(name)) missing.push(`${name} is named by no SDK test`);
+ if (VALUE_KINDS.has(kindOf.get(name)) && !exercised.has(name)) {
+ missing.push(`${name} is called by no golden project`);
+ }
+ }
+ return missing;
+}
+
+const problems = [];
+const rows = [];
+for (const sub of SUBSYSTEMS) {
+ const missing = shortfall(sub);
+ rows.push({ id: sub.id, tier: sub.tier, missing });
+ const owed = OWED[sub.id];
+ if (sub.tier === 'experimental') {
+ if (owed) problems.push(`"${sub.id}" is experimental and in OWED — nothing is owed below the bar`);
+ continue;
+ }
+ if (owed) {
+ if (!missing.length) {
+ problems.push(`"${sub.id}" now clears the bar — take it out of OWED, it is not owed anything`);
+ continue;
+ }
+ const gone = owed.filter((n) => !missing.includes(n));
+ if (gone.length) problems.push(`"${sub.id}" no longer owes: ${gone.join('; ')} — OWED is stale`);
+ const unlisted = missing.filter((n) => !owed.includes(n));
+ if (unlisted.length) {
+ problems.push(`"${sub.id}" is ${sub.tier} and short of the bar in a way OWED does not admit: `
+ + unlisted.join('; '));
+ }
+ continue;
+ }
+ if (missing.length) {
+ problems.push(`"${sub.id}" is published as ${sub.tier} without clearing the bar: ${missing.join('; ')}`);
+ }
+}
+
+if (REPORT) {
+ for (const tier of ['public', 'beta', 'experimental']) {
+ console.log(`\n## ${tier}\n`);
+ for (const r of rows.filter((x) => x.tier === tier)) {
+ console.log(r.missing.length ? ` ${r.id}\n ${r.missing.join('\n ')}` : ` ${r.id} — clears the bar`);
+ }
+ }
+ process.exit(0);
+}
+
+if (problems.length) {
+ console.error('check-tier-bar: a published tier is a promise, and these are not backed.\n');
+ for (const p of problems) console.error(` ${p}`);
+ console.error('\nEarn it — document the entry, name it in a test, have a golden project call it —'
+ + ' or say it is experimental, which is the honest verdict for something nobody has held up yet.');
+ process.exit(1);
+}
+
+const clears = rows.filter((r) => r.tier !== 'experimental' && !r.missing.length).length;
+const above = rows.filter((r) => r.tier !== 'experimental').length;
+console.log(`check-tier-bar: ${above} subsystem(s) above experimental — ${clears} clear the bar,`
+ + ` ${Object.keys(OWED).length} owe what they were published short of.`);
diff --git a/tools/gates.mjs b/tools/gates.mjs
index 0cd7eeac4..c3a8ab8f7 100644
--- a/tools/gates.mjs
+++ b/tools/gates.mjs
@@ -172,6 +172,10 @@ export const GATES = [
// The per-symbol tiers say what is frozen; this says what a creator can build
// on, and refuses a published verdict the tags do not carry.
{ id: 'subsystem-tiers', run: 'node tools/check-subsystem-tiers.mjs' },
+ // And whether the verdict was earned. subsystem-tiers holds the table against
+ // the tags; this holds a tier above experimental against the same evidence
+ // check-freeze-bar asks of a @public symbol.
+ { id: 'tier-bar', run: 'node tools/check-tier-bar.mjs' },
{ id: 'examples', run: 'node build-tools/cli.js check-examples' },
{ id: 'documents', run: 'node build-tools/cli.js validate-documents' },
];
diff --git a/tools/lib/apiEvidence.mjs b/tools/lib/apiEvidence.mjs
new file mode 100644
index 000000000..4813b20d2
--- /dev/null
+++ b/tools/lib/apiEvidence.mjs
@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright (c) 2024-present ESEngine Team
+/**
+ * @file apiEvidence.mjs — the three things that hold a promise about a symbol up.
+ *
+ * A stability claim is only worth the evidence under it: documentation, because
+ * the freeze is the moment the contract stops being readable from the code; a
+ * test, because a shape nothing pins moves with the first thing that touches it;
+ * and a real game, because a symbol no chain ever calls has never been tried.
+ *
+ * One definition, because two now ask: `check-freeze-bar` about a @public symbol
+ * and `check-tier-bar` about the entry a subsystem publishes its verdict on. Two
+ * copies would be two bars called by one name.
+ */
+import { readFileSync, readdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { SDK, ts, ENTRIES, createSdkProgram, leadingDoc, docProseLines } from './sdkProgram.mjs';
+import { GOLDEN, projectDir } from '../goldenProjects.mjs';
+
+/** Snapshot kinds a game calls at runtime; the rest are shapes. */
+export const VALUE_KINDS = new Set(['class', 'enum', 'function', 'const', 'value', 'namespace']);
+
+function walk(dir, onFile, skip) {
+ let entries;
+ try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+ for (const e of entries) {
+ const p = join(dir, e.name);
+ if (skip(p, e.name)) continue;
+ if (e.isDirectory()) walk(p, onFile, skip);
+ else onFile(p);
+ }
+}
+
+/** A leading doc block carrying at least one line that is not a tag. */
+export function hasDocProse(decl) {
+ return docProseLines(leadingDoc(decl)).length > 0;
+}
+
+/** Every identifier named anywhere in the SDK's tests. */
+export function testedIdentifiers() {
+ const seen = new Set();
+ const skip = (p, name) => name === 'node_modules' || name === 'dist';
+ walk(join(SDK, 'src'), collect, skip);
+ walk(join(SDK, 'tests'), collect, skip);
+ function collect(p) {
+ if (!/\.test\.ts$/.test(p)) return;
+ for (const id of readFileSync(p, 'utf8').match(/[A-Za-z_$][\w$]*/g) ?? []) seen.add(id);
+ }
+ return seen;
+}
+
+// Every entry, not just the root one: the SDK ships nine, and a symbol reached
+// through `esengine/spine` is as exercised as one reached through `esengine`.
+const ESENGINE_IMPORT = /import\s+(?:type\s+)?\{([^}]*)\}\s*from\s*['"]esengine(?:\/[^'"]+)?['"]/g;
+
+/** Symbols each golden project imports from an `esengine` entry, as `name -> [projectId]`. */
+export function exercisedByGolden() {
+ const out = new Map();
+ for (const g of GOLDEN) {
+ const dir = projectDir(g.id);
+ if (!existsSync(dir)) continue;
+ walk(dir, (p) => {
+ if (!/\.ts$/.test(p) || /\.d\.ts$/.test(p)) return;
+ const src = readFileSync(p, 'utf8');
+ for (const m of src.matchAll(ESENGINE_IMPORT)) {
+ for (const raw of m[1].split(',')) {
+ const name = raw.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0].trim();
+ if (!name) continue;
+ if (!out.has(name)) out.set(name, new Set());
+ out.get(name).add(g.id);
+ }
+ }
+ }, (p, name) => name === '.esengine' || name === 'node_modules' || name === 'dist');
+ }
+ return out;
+}
+
+/**
+ * Where each of `wanted` is declared, across every SDK entry, aliases resolved.
+ * A name that resolves to nothing is absent from the map — a caller has to treat
+ * that as "cannot tell", not as "meets the bar".
+ */
+export function declarationsOf(wanted, program, checker) {
+ const out = new Map();
+ for (const entryPath of Object.values(ENTRIES)) {
+ const sourceFile = program.getSourceFile(join(SDK, entryPath));
+ const moduleSymbol = sourceFile && checker.getSymbolAtLocation(sourceFile);
+ if (!moduleSymbol) continue;
+ for (const symbol of checker.getExportsOfModule(moduleSymbol)) {
+ if (out.has(symbol.name) || !wanted.has(symbol.name)) continue;
+ const resolved = symbol.flags & ts.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+ const decl = resolved.declarations?.[0];
+ if (decl) out.set(symbol.name, decl);
+ }
+ }
+ return out;
+}
+
+export { createSdkProgram };
+
+/**
+ * Symbols the evidence above cannot see, and why. Each is handed to a system body
+ * by a declared parameter, or built by the engine on a game's behalf: a golden
+ * project runs one every frame and no import list ever names it. A bar asking
+ * about these is blind, not unmet, which is a different answer.
+ */
+const RECEIVED = 'received from a declared parameter, never imported — golden projects run it, no import list names it';
+const HANDED_BACK = 'answered by a frozen factory, never imported — a game names the factory, not this';
+export const BLIND = {
+ InputMap: HANDED_BACK,
+ // Same blindness, from the other direction: the map's rebind scan builds one
+ // when a player binds a mouse button, so a certified game runs it without any
+ // import list ever naming it.
+ MouseButton: 'built by InputMap\'s rebind scan on the game\'s behalf — run by a golden project, named by none',
+ // Same shape of blindness: the engine maintains this one from Parent, so a
+ // game reads it and every golden project's layout walks it every frame, but
+ // nothing imports the name.
+ Children: 'engine-maintained from Parent — walked every frame, named in no import list',
+ CommandsInstance: RECEIVED,
+ EntityCommands: RECEIVED,
+ EventReaderInstance: RECEIVED,
+ EventWriterInstance: RECEIVED,
+ QueryInstance: RECEIVED,
+ RemovedQueryInstance: RECEIVED,
+ ResMutInstance: RECEIVED,
+};
diff --git a/tools/releaseGate.mjs b/tools/releaseGate.mjs
index bdd007068..57191476e 100644
--- a/tools/releaseGate.mjs
+++ b/tools/releaseGate.mjs
@@ -299,6 +299,15 @@ export const CRITERIA = [
answeredBy: 'node tools/check-plugin-api-contract.mjs',
needs: ['tools/check-plugin-api-contract.mjs', 'editor-api/index.ts'],
},
+ {
+ id: 'a-tier-above-experimental-is-earned',
+ says: 'no subsystem is published as beta or public without the evidence a @public symbol needs',
+ // The other half of `frozen-api-earned`, one level up. A tier is a promise to
+ // a creator, and before this the only thing holding one was the prose beside
+ // it — two rows said "not read for a tier yet", which is a note, not a bar.
+ answeredBy: 'node tools/check-tier-bar.mjs',
+ needs: ['tools/check-tier-bar.mjs', 'tools/lib/apiEvidence.mjs', 'tools/apiSubsystems.mjs'],
+ },
{
id: 'every-subsystem-has-a-verdict',
says: 'every part of the engine publishes a tier at the size a creator builds in, and the tags carry it',