Game certification and SDK self-tests
Prepare deterministic scenarios, understand validation reports and resolve publication blockers.
From upload to publication
An uploaded build is staged privately and automatically queued when validation policy enables it. In the provider game detail, select the build, inspect validation history and download its JSON or readable report. Correct the reported issue, upload a new immutable version when code changes, and run validation again. Staff use Games → Certification for review and publication eligibility. A queued job needs a connected isolated worker; waiting is not a passed test.
Profiles and declared features
Staff configure the engine, profile, supported devices, orientation, required events and features in game metadata. The standard profile leaves SDK self-test optional. Integrated, runner, puzzle and arcade profiles require their configured event scenarios; explicitly required events and declared score, progress, rewards, achievements or leaderboard features also require evidence. Ask staff for the exact ruleset and agreed event definitions. Do not claim unrelated optional features. Desktop-only declarations do not require mobile tests.
Self-test contract v1
The existing SDK exposes PlayIsland.registerSelfTest({ version: 1, scenarios }). Register named asynchronous functions after the SDK is ready. Registration returns false in normal production delivery and no scenarios execute there. Only the disposable certification runner enables the contract, using synthetic accounts and isolated state. There is no self-test URL that grants production rewards. Initialize the SDK during ordinary game startup, independently of the scenario. The example below assumes staff have registered started, score and session_ended for this build and permit a score of 5. Adapt payloads to your actual definitions.
const sdk = window.PlayIsland;
await sdk.getConfiguration(); // Ordinary startup, before any self-test.
function emitAndWait(name, data = {}) {
return new Promise((resolve, reject) => {
let eventId;
const off = sdk.onAcknowledgement(ack => {
if (ack.eventId !== eventId) return;
clearTimeout(timer);
off();
ack.accepted ? resolve() : reject(Error('Event rejected'));
});
const timer = setTimeout(() => {
off();
reject(Error('No event acknowledgement'));
}, 5000);
eventId = sdk.event(name, data);
});
}
sdk.registerSelfTest({
version: 1,
scenarios: {
integration: async () => {
await emitAndWait('started');
await emitAndWait('score', { score: 5 });
await emitAndWait('session_ended');
}
}
});Use a module script or an async startup function for the example's await. Native engine adapters can register the same JavaScript callbacks and invoke engine test actions from them. Wait for acknowledgements instead of returning success immediately. Scenario names use lowercase letters, digits, underscores or hyphens, up to 60 characters, with at most 20 scenarios. completed, failed, abandoned and session_ended each terminate a session. Do not emit a second terminal event afterward. Completion also requires at least three seconds of session time. Never include play tokens, player identifiers, coins, XP or VIP balances in game event payloads. Rewards come from registered gameplay events and staff-owned server rules.
What the runner actually verifies
The runner observes ordinary startup before invoking scenarios, then verifies accepted SDK messages and effects through the platform's real session/event and reward services in isolated state. A scenario's own success claim is insufficient. Feature checks require observable results; unavailable scenarios remain Inconclusive. Purchases, sign-in, general saves and multiplayer account actions are unavailable in this harness. Passing a self-test proves that this integration scenario works. It does not prove real gameplay triggers the same events or that the game is enjoyable, visually correct or usable. Manual gameplay review remains necessary. Performance and layout checks are bounded measurements in Chromium; physical devices and Safari need separate acceptance.
Reading the decision
| Status | Meaning |
|---|---|
| Compatible | Mandatory checks passed and no optional limitations remain |
| Limited | Mandatory checks passed, with disclosed optional limitations; publication depends on policy |
| Pending Review | Automated requirements are satisfied, but staff approval is required |
| Rejected | A mandatory requirement failed, or staff requested corrections/rejected the build |
| Inconclusive | Required evidence could not be completed reliably |
A job can finish execution and produce a Rejected decision. Missing, skipped or timed-out mandatory checks cannot be approved. Only owners may record an audited exception for an executed non-security failure; security and missing-evidence checks cannot be waived. The report identifies expected behavior, observed behavior, fixed diagnostic guidance and the rules/SDK/validator versions used.
Build identity and limitations
Certification binds the exact archive and relevant metadata, event schemas, reward rules and feature definitions. Changing them can require revalidation before publication. A previous active release keeps serving while an update is reviewed. Existing legacy releases are labelled legacy, not retrospectively certified. External URL execution is currently disabled and remains Inconclusive. Hosted games should bundle dependencies; declared remote dependencies also remain Inconclusive when the network-disabled runner cannot test them. Precompressed .gz/.br builds currently fail hosting compatibility. A visible canvas or a successful page load never proves gameplay.