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.

fix(aot): the last duty is sampled, and the ledger counts per road

yhh707c3d97d948
diff --git a/fixtures/aot-conformance/src/main.ts b/fixtures/aot-conformance/src/main.ts
index 0347f6817..5ccda17c0 100644
--- a/fixtures/aot-conformance/src/main.ts
+++ b/fixtures/aot-conformance/src/main.ts
@@ -7,8 +7,8 @@ import {
} from 'esengine';
import {
- Doomed, Mover, Tally, absorbSystem, announceSystem, clampSystem, driftSystem,
- reapSystem, tallySystem,
+ Doomed, Mover, Tally, absorbSystem, announceSystem, censusSystem, clampSystem,
+ driftSystem, reapSystem, tallySystem,
} from './systems.generated';
import { DOOMED, SEED } from './seed.generated';
@@ -47,7 +47,7 @@ const reportSystem = defineSystem(
let ttl = 0;
for (const [, d] of doomed) { alive++; ttl += d.ttl; }
console.log(`CONF ${frame} ${time.delta} ${JSON.stringify(rows)} `
- + `${JSON.stringify([tally.bounces, tally.frames])} ${ticked} `
+ + `${JSON.stringify([tally.bounces, tally.frames, tally.census])} ${ticked} `
+ `${JSON.stringify([alive, ttl])}`);
frame++;
},
@@ -61,5 +61,6 @@ addSystemToSchedule(Schedule.Update, tallySystem);
addSystemToSchedule(Schedule.Update, announceSystem);
addSystemToSchedule(Schedule.Update, absorbSystem);
addSystemToSchedule(Schedule.Update, reapSystem);
+addSystemToSchedule(Schedule.Update, censusSystem);
addSystemToSchedule(Schedule.Update, watchSystem);
addSystemToSchedule(Schedule.Update, reportSystem);
diff --git a/fixtures/aot-conformance/src/systems.generated.ts b/fixtures/aot-conformance/src/systems.generated.ts
index 4c5ee7be6..cf619fcd5 100644
--- a/fixtures/aot-conformance/src/systems.generated.ts
+++ b/fixtures/aot-conformance/src/systems.generated.ts
@@ -19,7 +19,7 @@ export const Mover = defineComponent('ConfMover', { x: 0, speed: 0, bounces: 0 }
/** A resource the compiled code WRITES. A ResMut lands in the mirror and
* nowhere else, so it is in the world only if the road copied it back. */
-export const Tally = defineResource({ bounces: 0, frames: 0 }, 'ConfTally');
+export const Tally = defineResource({ bounces: 0, frames: 0, census: 0 }, 'ConfTally');
/** A second population, so the road that despawns never touches the rows the
* C++ harness models. */
@@ -120,3 +120,22 @@ export const reapSystem = defineSystem(
},
{ name: 'ConfReap' },
);
+
+/**
+ * A compiled query over rows that LEAVE, which is the only way the cached row
+ * table is ever invalidated. A road reusing last frame's addresses walks a slot
+ * nothing owns any more and this number stops agreeing.
+ *
+ * @compiled
+ */
+export const censusSystem = defineSystem(
+ [Query(Doomed), ResMut(Tally)],
+ (query, tally) => {
+ for (const [, d] of query) {
+ tally.modify((t) => {
+ t.census = t.census + d.ttl + 1;
+ });
+ }
+ },
+ { name: 'ConfCensus' },
+);
diff --git a/sdk/tests/aot-conformance.test.ts b/sdk/tests/aot-conformance.test.ts
index ac8da855e..c83a3bb0f 100644
--- a/sdk/tests/aot-conformance.test.ts
+++ b/sdk/tests/aot-conformance.test.ts
@@ -113,6 +113,8 @@ async function play(compiled: { wasm: Uint8Array; manifest: AotManifest } | null
app.addSystemToSchedule(Schedule.Update, fixture.announceSystem);
app.addSystemToSchedule(Schedule.Update, fixture.absorbSystem);
app.addSystemToSchedule(Schedule.Update, fixture.reapSystem);
+ // After the reap, so its query walks a set that SHRANK this frame.
+ app.addSystemToSchedule(Schedule.Update, fixture.censusSystem);
// Interpreted, and last: the Changed ticks a twin leaves are the one duty
// no value in the trace can show. A watcher counts what a filter matched,
// which is the same question a game asks of change detection.
@@ -160,8 +162,9 @@ async function play(compiled: { wasm: Uint8Array; manifest: AotManifest } | null
}));
// A ResMut is written into the MIRROR; this reads the world, which is
// where it lands only if the road copied it back.
- const tally = app.getResource(fixture.Tally) as { bounces: number; frames: number };
- resource.push([tally.bounces, tally.frames]);
+ const tally = app.getResource(fixture.Tally) as
+ { bounces: number; frames: number; census: number };
+ resource.push([tally.bounces, tally.frames, tally.census]);
// What the event fed and the command removed. A despawn that reached
// one world and not the other is a count that stops agreeing.
const alive = doomed.filter((e) => app.world.valid(e));
@@ -188,7 +191,7 @@ describe.skipIf(!EMCC)('one source, interpreted and compiled', () => {
// Installed is not the same question as ran, and a differential cannot
// tell them apart — the closure that would have run produces the same
// numbers. Three systems, every frame.
- expect(twins.calls).toBe(FRAMES * 6);
+ expect(twins.calls).toBe(FRAMES * 7);
expect(interpreted.calls).toBe(0);
// Frame for frame, so a divergence names the frame it began on rather
@@ -396,7 +399,7 @@ describe('the inputs a loading host builds against', () => {
// The resource a twin WROTE, read back out of the world. A road that
// never copied the mirror back leaves it at its default while every
// row above still agrees, which is why it is traced separately.
- resourceFields: ['bounces', 'frames'],
+ resourceFields: ['bounces', 'frames', 'census'],
resource: run.resource,
// What a `Changed(Mover)` filter matched after each frame. Nothing
// in the values above shows a tick, and a road that stopped marking
diff --git a/sdk/tests/fixtures/conformance-systems.ts b/sdk/tests/fixtures/conformance-systems.ts
index 6a4511e00..ecc8302b1 100644
--- a/sdk/tests/fixtures/conformance-systems.ts
+++ b/sdk/tests/fixtures/conformance-systems.ts
@@ -21,7 +21,7 @@ export const Mover = defineComponent('ConfMover', { x: 0, speed: 0, bounces: 0 }
/** A resource the compiled code WRITES. A ResMut lands in the mirror and
* nowhere else, so it is in the world only if the road copied it back. */
-export const Tally = defineResource({ bounces: 0, frames: 0 }, 'ConfTally');
+export const Tally = defineResource({ bounces: 0, frames: 0, census: 0 }, 'ConfTally');
/** A second population, so the road that despawns never touches the rows the
* C++ harness models. */
@@ -122,3 +122,22 @@ export const reapSystem = defineSystem(
},
{ name: 'ConfReap' },
);
+
+/**
+ * A compiled query over rows that LEAVE, which is the only way the cached row
+ * table is ever invalidated. A road reusing last frame's addresses walks a slot
+ * nothing owns any more and this number stops agreeing.
+ *
+ * @compiled
+ */
+export const censusSystem = defineSystem(
+ [Query(Doomed), ResMut(Tally)],
+ (query, tally) => {
+ for (const [, d] of query) {
+ tally.modify((t) => {
+ t.census = t.census + d.ttl + 1;
+ });
+ }
+ },
+ { name: 'ConfCensus' },
+);
diff --git a/tests/aot/generated/conformance/estella_offsets.h b/tests/aot/generated/conformance/estella_offsets.h
index 6fe68587b..a084ebc01 100644
--- a/tests/aot/generated/conformance/estella_offsets.h
+++ b/tests/aot/generated/conformance/estella_offsets.h
@@ -11,6 +11,7 @@
#define ES_OFF_ConfMover_speed 8u
#define ES_OFF_ConfMover_x 0u
#define ES_OFF_ConfTally_bounces 0u
+#define ES_OFF_ConfTally_census 16u
#define ES_OFF_ConfTally_frames 8u
#define ES_OFF_Time_delta 0u
diff --git a/tests/aot/generated/conformance/handshake.h b/tests/aot/generated/conformance/handshake.h
index dce8ff564..f4e0f840a 100644
--- a/tests/aot/generated/conformance/handshake.h
+++ b/tests/aot/generated/conformance/handshake.h
@@ -2,4 +2,4 @@
/* The contract half of the handshake. The width half is the harness. */
#define ES_CONF_EXPECTED_CONTRACT_HASH 0xaa8849ed8d31d9a0ULL
/* And which BUILD the artifact beside this one is. */
-#define ES_CONF_EXPECTED_MODULE_CONTRACT 0x1f3a750c220381a4ULL
+#define ES_CONF_EXPECTED_MODULE_CONTRACT 0xc3d0e057d5701a2eULL
diff --git a/tests/aot/generated/conformance/systems.c b/tests/aot/generated/conformance/systems.c
index 7708ab83a..1b7e06e86 100644
--- a/tests/aot/generated/conformance/systems.c
+++ b/tests/aot/generated/conformance/systems.c
@@ -6,8 +6,8 @@
/* Which BUILD this is, for a loader holding the sidecar written beside
it. The two digests above answer "is this engine right" and "are the
project shapes right"; neither answers "are these two the same pair". */
-ES_EXPORT uint32_t es_module_contract_lo(void) { return 0x220381a4u; }
-ES_EXPORT uint32_t es_module_contract_hi(void) { return 0x1f3a750cu; }
+ES_EXPORT uint32_t es_module_contract_lo(void) { return 0xd5701a2eu; }
+ES_EXPORT uint32_t es_module_contract_hi(void) { return 0xc3d0e057u; }
ES_EXPORT void es_sys_ConfDrift(es_addr_t es_ctx) {
const EsSysCtx *es_c = (const EsSysCtx *)ES_PTR(es_ctx);
@@ -143,3 +143,19 @@ ES_EXPORT void es_sys_ConfReap(es_addr_t es_ctx) {
}
*es_cmd_at = es_cmd_n;
}
+
+ES_EXPORT void es_sys_ConfCensus(es_addr_t es_ctx) {
+ const EsSysCtx *es_c = (const EsSysCtx *)ES_PTR(es_ctx);
+ const EsQueryRows *es_queries = (const EsQueryRows *)ES_PTR(es_c->queries);
+ const es_addr_t *es_resources = (const es_addr_t *)ES_PTR(es_c->resources);
+ unsigned char *tally_1 = ES_PTR(es_resources[0]);
+ {
+ const es_addr_t *es_rows0 = (const es_addr_t *)ES_PTR(es_queries[0].rows);
+ const es_addr_t es_n0 = es_queries[0].count;
+ for (es_addr_t es_i0 = 0; es_i0 < es_n0; ++es_i0) {
+ const es_addr_t *es_row0 = es_rows0 + es_i0 * 2u;
+ unsigned char *d_2 = ES_PTR(es_row0[1]);
+ es_set_f64(tally_1 + ES_OFF_ConfTally_census, ((es_f64(tally_1 + ES_OFF_ConfTally_census) + es_f64(d_2 + ES_OFF_ConfDoomed_ttl)) + 1.0));
+ }
+ }
+}
diff --git a/tests/aot/generated/conformance/systems_decl.c b/tests/aot/generated/conformance/systems_decl.c
index 8dff9fd51..06587ff87 100644
--- a/tests/aot/generated/conformance/systems_decl.c
+++ b/tests/aot/generated/conformance/systems_decl.c
@@ -20,6 +20,7 @@ ES_EXPORT void es_sys_ConfTally(es_addr_t es_ctx);
ES_EXPORT void es_sys_ConfAnnounce(es_addr_t es_ctx);
ES_EXPORT void es_sys_ConfAbsorb(es_addr_t es_ctx);
ES_EXPORT void es_sys_ConfReap(es_addr_t es_ctx);
+ES_EXPORT void es_sys_ConfCensus(es_addr_t es_ctx);
/* The systems in this file, and what each one needs filled in. */
static const char *const es_sys_ConfDrift_q0_comps[] = { "ConfMover" };
@@ -46,6 +47,11 @@ static const EsQueryDecl es_sys_ConfAbsorb_queries[] = { { es_sys_ConfAbsorb_q0_
static const char *const es_sys_ConfReap_q0_comps[] = { "ConfDoomed" };
static const unsigned char es_sys_ConfReap_q0_mut[] = { 1u };
static const EsQueryDecl es_sys_ConfReap_queries[] = { { es_sys_ConfReap_q0_comps, es_sys_ConfReap_q0_mut, 1u } };
+static const char *const es_sys_ConfCensus_q0_comps[] = { "ConfDoomed" };
+static const unsigned char es_sys_ConfCensus_q0_mut[] = { 0u };
+static const EsQueryDecl es_sys_ConfCensus_queries[] = { { es_sys_ConfCensus_q0_comps, es_sys_ConfCensus_q0_mut, 1u } };
+static const char *const es_sys_ConfCensus_resources[] = { "ConfTally" };
+static const unsigned char es_sys_ConfCensus_resources_mut[] = { 1u };
ES_EXPORT const EsSystemDecl es_systems[] = {
{ "ConfDrift", es_sys_ConfDrift, es_sys_ConfDrift_queries, es_sys_ConfDrift_resources, es_sys_ConfDrift_resources_mut, 1u, 1u },
@@ -54,5 +60,6 @@ ES_EXPORT const EsSystemDecl es_systems[] = {
{ "ConfAnnounce", es_sys_ConfAnnounce, es_sys_ConfAnnounce_queries, NULL, NULL, 1u, 0u },
{ "ConfAbsorb", es_sys_ConfAbsorb, es_sys_ConfAbsorb_queries, NULL, NULL, 2u, 0u },
{ "ConfReap", es_sys_ConfReap, es_sys_ConfReap_queries, NULL, NULL, 1u, 0u },
+ { "ConfCensus", es_sys_ConfCensus, es_sys_ConfCensus_queries, es_sys_ConfCensus_resources, es_sys_ConfCensus_resources_mut, 1u, 1u },
};
-ES_EXPORT const uint32_t es_system_count = 6u;
+ES_EXPORT const uint32_t es_system_count = 7u;
diff --git a/tests/aot/generated/conformance/trace.json b/tests/aot/generated/conformance/trace.json
index e05be7641..c9d1db947 100644
--- a/tests/aot/generated/conformance/trace.json
+++ b/tests/aot/generated/conformance/trace.json
@@ -295,56 +295,69 @@
],
"resourceFields": [
"bounces",
- "frames"
+ "frames",
+ "census"
],
"resource": [
[
2,
- 1
+ 1,
+ 9
],
[
4,
- 2
+ 2,
+ 24
],
[
7,
- 3
+ 3,
+ 36
],
[
10,
- 4
+ 4,
+ 44
],
[
13,
- 5
+ 5,
+ 44
],
[
17,
- 6
+ 6,
+ 44
],
[
21,
- 7
+ 7,
+ 44
],
[
26,
- 8
+ 8,
+ 44
],
[
31,
- 9
+ 9,
+ 44
],
[
36,
- 10
+ 10,
+ 44
],
[
41,
- 11
+ 11,
+ 44
],
[
46,
- 12
+ 12,
+ 44
]
],
"ticks": [
diff --git a/tools/check-aot-duties.mjs b/tools/check-aot-duties.mjs
index 030bec714..c1bcf98ae 100644
--- a/tools/check-aot-duties.mjs
+++ b/tools/check-aot-duties.mjs
@@ -119,25 +119,33 @@ for (const duty of DUTIES) {
* test agrees with whatever the road happens to do; only a differential does not.
*/
for (const duty of DUTIES) {
- const held = duty.differential ?? [];
- if (held.length === 0) {
- if (!duty.owed) {
- findings.push(`${duty.id}: no differential holds it against the interpreter, and no `
- + '`owed` says so. A duty checked only for presence is a duty nothing verifies.');
+ for (const road of ROADS) {
+ // A road that REFUSES the duty owes nothing: the systems that would need
+ // it never reach this road at all.
+ if (duty[road.id] === null || duty[road.id] === undefined) continue;
+ const held = duty.differential?.[road.id] ?? [];
+ const owed = duty.owed?.[road.id];
+ if (held.length === 0) {
+ if (!owed) {
+ findings.push(`${duty.id}: the ${road.id} road performs it and no differential holds `
+ + 'it against the interpreter, with no `owed` saying so. A duty checked only for '
+ + 'presence is a duty nothing verifies.');
+ }
+ continue;
}
- continue;
- }
- if (duty.owed) {
- findings.push(`${duty.id}: \`owed\` says nothing holds it, and ${held.length} `
- + 'differential(s) are named. One of the two has stopped being true.');
- }
- for (const at of held) {
- let src = null;
- try { src = read(at.path); } catch { src = null; }
- if (src === null) findings.push(`${duty.id}: ${at.path} is gone, and it is named as holding it.`);
- else if (!at.probe.test(src)) {
- findings.push(`${duty.id}: ${at.path} no longer matches ${at.probe} — the differential `
- + 'this list points at has moved or been dropped.');
+ if (owed) {
+ findings.push(`${duty.id}: \`owed.${road.id}\` says nothing holds it, and ${held.length} `
+ + 'differential(s) are named. One of the two has stopped being true.');
+ }
+ for (const at of held) {
+ let src = null;
+ try { src = read(at.path); } catch { src = null; }
+ if (src === null) {
+ findings.push(`${duty.id}: ${at.path} is gone, and it is named as holding it.`);
+ } else if (!at.probe.test(src)) {
+ findings.push(`${duty.id}: ${at.path} no longer matches ${at.probe} — the `
+ + 'differential this list points at has moved or been dropped.');
+ }
}
}
}
@@ -180,10 +188,15 @@ if (findings.length > 0) {
process.exit(1);
}
const skipped = DUTIES.filter((d) => ROADS.some((r) => d[r.id] === null)).length;
-const owed = DUTIES.filter((d) => (d.differential ?? []).length === 0);
+// Counted per ROAD, because a duty held on one road and owed on the other is
+// exactly the state a single number would round away.
+const pairs = DUTIES.flatMap((d) => ROADS
+ .filter((r) => d[r.id] !== null && d[r.id] !== undefined)
+ .map((r) => ({ id: d.id, road: r.id, owed: d.owed?.[r.id] })));
+const owed = pairs.filter((p) => p.owed);
console.log(`check-aot-duties: ${DUTIES.length} duties across ${ROADS.length} roads — `
+ `${DUTIES.length - skipped} performed by both, ${skipped} refused by capability, `
+ `${everyCall.size} call(s) accounted for.`);
-console.log(` ${DUTIES.length - owed.length} held against the interpreter by a differential; `
- + `${owed.length} owed one:`);
-for (const d of owed) console.log(` ${d.id}: ${d.owed}`);
+console.log(` ${pairs.length - owed.length} of ${pairs.length} duty/road pairs held against the `
+ + `interpreter by a differential; ${owed.length} owed one:`);
+for (const p of owed) console.log(` ${p.id} (${p.road}): ${p.owed}`);
diff --git a/tools/lib/aotDuties.mjs b/tools/lib/aotDuties.mjs
index 9368c62ab..dd1beeb27 100644
--- a/tools/lib/aotDuties.mjs
+++ b/tools/lib/aotDuties.mjs
@@ -23,12 +23,21 @@
* road that cannot (`sdk/src/ecs/aot/executorCapabilities.ts`). There is no
* third answer: a duty a road neither performs nor refuses systems for is the
* shape all three bugs had.
+ *
+ * And presence is not correctness. `resource-write-back` was implemented on both
+ * roads and accounted for here while no source form existed that the two lowered
+ * the same way, so every duty also names the DIFFERENTIAL that holds it against
+ * the interpreter — per road, because a road that refuses a duty owes none.
*/
/**
* `web` and `native` list the calls that PERFORM the duty on that road, or null
* where the road does not perform it — and then `excusedBy` names the capability
* that keeps such a system off it, which the checker holds against the model.
+ *
+ * `differential` and `owed` are keyed the same way: a road that performs a duty
+ * owes either a differential holding it against the interpreter, or a sentence
+ * saying nothing does.
*/
export const DUTIES = [
{
@@ -39,19 +48,26 @@ export const DUTIES = [
// and is told where the script pools are.
web: ['runtime.addresses.componentNamed', 'runtime.ctx.build'],
native: ['world.scriptSpanOf', 'bindings.scriptRows'],
- differential: [
- { path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.trace\[f\]/ },
- { path: 'tools/verify-native-conformance.mjs', probe: /disagrees at frame/ },
- ],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.trace\[f\]/ }],
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /disagrees at frame/ }],
+ },
},
{
id: 'layout-vouched',
what: 'an address is reused only while something says the rows have not moved',
web: ['world.layoutEpoch'],
native: ['world.layoutEpoch', 'world.scriptLayoutEpoch'],
- // The fixture seeds a world and never moves a row in it, so the cached
- // table is never invalidated on any road. Nothing holds the REUSE.
- owed: 'a differential whose world gains and loses rows mid-run',
+ differential: {
+ // `ConfCensus` queries the population a despawn empties, so a host
+ // keeping last frame's table walks a slot nothing owns. Freezing the
+ // epoch handed to it is red at frame 2: 45 against the author's 36.
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /about the resource/ }],
+ },
+ owed: {
+ web: "the suite's world answers no layout epoch — its engine is a mock — so the "
+ + 'wasm road repacks every frame and the reuse is never taken',
+ },
},
{
id: 'resource-in',
@@ -60,44 +76,50 @@ export const DUTIES = [
native: ['resources.addressOf', 'resources.bytesOf', 'bindings.resource'],
// Jointly with the rows: `Res(Time)` is what moves them, so a resource
// at the wrong address is a row that disagrees on frame 0.
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.trace\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.trace\[f\]/ }],
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /disagrees at frame/ }],
+ },
},
{
id: 'resource-write-back',
what: 'a ResMut the call wrote lands in the world, not only in the mirror',
web: ['runtime.addresses.resourceWriteBack'],
native: ['resources.writeBack'],
- differential: [
- { path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.resource\[f\]/ },
- { path: 'tools/verify-native-conformance.mjs', probe: /about the resource/ },
- ],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.resource\[f\]/ }],
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /about the resource/ }],
+ },
},
{
id: 'call',
what: 'the compiled function runs',
web: ['twin.call'],
native: ['bindings.run'],
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.trace\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.trace\[f\]/ }],
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /disagrees at frame/ }],
+ },
},
{
id: 'call-counted',
what: 'App.compiledSystems can tell a module that loaded from one that ran',
web: ['runtime.systems.noteCall'],
native: ['systems.noteCall'],
- differential: [
- { path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.calls/ },
- { path: 'tools/verify-native-conformance.mjs', probe: /were dispatched to/ },
- ],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.calls/ }],
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /were dispatched to/ }],
+ },
},
{
id: 'changed-ticks',
what: 'the Changed ticks the compiled code could not leave',
web: ['world.isChangeTracked', 'world.markChanged', 'world.queryEntities'],
native: ['world.isChangeTracked', 'world.markChanged', 'world.queryEntities'],
- differential: [
- { path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.ticks\[f\]/ },
- { path: 'tools/verify-native-conformance.mjs', probe: /changed row\(s\) at frame/ },
- ],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.ticks\[f\]/ }],
+ native: [{ path: 'tools/verify-native-conformance.mjs', probe: /changed row\(s\) at frame/ }],
+ },
},
{
id: 'event-payloads-in',
@@ -105,9 +127,9 @@ export const DUTIES = [
web: ['runtime.addresses.payloadRows'],
native: null,
excusedBy: 'eventRead',
- // The WASM road only, and that is the whole entry: on the loading road
- // these systems are refused, so its agreement is the interpreter's own.
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ },
},
{
id: 'event-payloads-released',
@@ -115,9 +137,9 @@ export const DUTIES = [
web: ['runtime.addresses.releasePayloads'],
native: null,
excusedBy: 'eventRead',
- // The WASM road only, and that is the whole entry: on the loading road
- // these systems are refused, so its agreement is the interpreter's own.
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ },
},
{
id: 'event-records-sized',
@@ -125,9 +147,9 @@ export const DUTIES = [
web: ['runtime.ctx.setRecordLengths'],
native: null,
excusedBy: 'eventWrite',
- // The WASM road only, and that is the whole entry: on the loading road
- // these systems are refused, so its agreement is the interpreter's own.
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ },
},
{
id: 'events-out',
@@ -135,9 +157,9 @@ export const DUTIES = [
web: ['runtime.ctx.events', 'runtime.addresses.sendEvent'],
native: null,
excusedBy: 'eventWrite',
- // The WASM road only, and that is the whole entry: on the loading road
- // these systems are refused, so its agreement is the interpreter's own.
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ },
},
{
id: 'commands-out',
@@ -145,9 +167,9 @@ export const DUTIES = [
web: ['runtime.ctx.commands', 'world.despawn'],
native: null,
excusedBy: 'commands',
- // The WASM road only, and that is the whole entry: on the loading road
- // these systems are refused, so its agreement is the interpreter's own.
- differential: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ differential: {
+ web: [{ path: 'sdk/tests/aot-conformance.test.ts', probe: /twins\.pop\[f\]/ }],
+ },
},
];