cuju-render 0.1.0__py3-none-any.whl

cuju/render/web/js/presentation/post.js

@@ -0,0 +1,327 @@
+// Copyright 2026 The cuju Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// Post passes of team packages, the features post.layer and post.fullscreen.
+//
+// A team's layer pass works on the team's own objects alone. The page draws the whole scene into a
+// small target writing depth only, then the team's players and effects with their own materials,
+// so the target holds what of the team the camera sees, and a pass of the team draws from it onto
+// the finished picture, a glow, an outline, pixels, a tint, a colour split, a blur or the team's
+// own shader. A full screen pass works on the whole picture, only during the team's own moment,
+// at most three seconds, at high quality, and never under reduced motion. Every pass's strength
+// goes through the flash governor. The degrade ladder drops a team's passes at its rung noPasses.
+
+import * as THREE from 'three';
+import { FullScreenQuad } from 'three/addons/postprocessing/Pass.js';
+
+export const TEAM_LAYERS = [10, 11];
+export const PASSES = ['glow', 'outline', 'pixelate', 'tint', 'chromatic', 'blur', 'custom'];
+// The passes that move the picture, which reduced motion leaves out.
+export const DISTORTING = ['pixelate', 'chromatic'];
+export const FULLSCREEN_SECONDS = 3;
+// The events that make a team's own moment, when a full screen pass may play.
+export const MOMENTS = ['goal', 'celebration.begin', 'winner.reveal', 'mvp.reveal', 'save', 'woodwork', 'reaction.begin', 'lineup.begin'];
+
+const PASS_INDEX = { glow: 0, outline: 1, pixelate: 2, tint: 3, chromatic: 4, blur: 5 };
+
+const VERTEX = `
+varying vec2 vUv;
+void main() {
+    vUv = uv;
+    gl_Position = vec4(position.xy, 0.0, 1.0);
+}`;
+
+const FRAGMENT = `
+uniform sampler2D tSource;
+uniform vec2 uTexel;
+uniform int uPass;
+uniform vec3 uColor;
+uniform float uStrength;
+uniform float uLayer;
+varying vec2 vUv;
+vec4 at(vec2 uv) { return texture2D(tSource, uv); }
+vec4 blur(vec2 uv, float r) {
+    vec4 s = vec4(0.0);
+    float w = 0.0;
+    for (int x = -2; x <= 2; x++) {
+        for (int y = -2; y <= 2; y++) {
+            float k = exp(-float(x * x + y * y) / 4.0);
+            s += at(uv + vec2(float(x), float(y)) * uTexel * r) * k;
+            w += k;
+        }
+    }
+    return s / w;
+}
+void main() {
+    vec4 c = at(vUv);
+    vec4 o = vec4(0.0);
+    if (uPass == 0) {
+        vec4 b = blur(vUv, 2.5);
+        o = vec4(uColor * b.a * uStrength, 0.0);
+    } else if (uPass == 1) {
+        float edge = 0.0;
+        for (int i = 0; i < 8; i++) {
+            float a = float(i) * 0.785398;
+            edge = max(edge, at(vUv + vec2(cos(a), sin(a)) * uTexel * 1.5).a);
+        }
+        edge = clamp(edge - c.a, 0.0, 1.0);
+        o = vec4(uColor * edge * uStrength, 0.0);
+    } else if (uPass == 2) {
+        vec2 cell = uTexel * (4.0 + 6.0 * uStrength);
+        vec4 p = at((floor(vUv / cell) + 0.5) * cell);
+        o = vec4(p.rgb, p.a * (uLayer > 0.5 ? 1.0 : clamp(uStrength, 0.0, 1.0)));
+    } else if (uPass == 3) {
+        o = vec4(mix(c.rgb, c.rgb * uColor * 1.6, clamp(uStrength, 0.0, 1.0)), c.a);
+    } else if (uPass == 4) {
+        vec2 d = uTexel * 3.0 * uStrength;
+        vec4 r = at(vUv + d);
+        vec4 b = at(vUv - d);
+        o = uLayer > 0.5 ? vec4(r.r * r.a, 0.0, b.b * b.a, 0.0) : vec4(r.r, c.g, b.b, 1.0);
+    } else {
+        vec4 b = blur(vUv, 1.0 + 2.0 * uStrength);
+        o = vec4(b.rgb, b.a);
+    }
+    // The layer target holds linear light without tone mapping, the picture is in sRGB.
+    if (uLayer > 0.5 && (uPass == 2 || uPass == 3 || uPass == 5)) {
+        o.rgb = pow(max(o.rgb, 0.0), vec3(0.4545));
+    }
+    gl_FragColor = o;
+}`;
+
+function passMaterial(blending) {
+    return new THREE.ShaderMaterial({
+        uniforms: {
+            tSource: { value: null }, uTexel: { value: new THREE.Vector2() }, uPass: { value: 0 },
+            uColor: { value: new THREE.Color(1, 1, 1) }, uStrength: { value: 1 }, uLayer: { value: 1 },
+        },
+        vertexShader: VERTEX, fragmentShader: FRAGMENT, depthTest: false, depthWrite: false, transparent: true,
+        blending,
+    });
+}
+
+// The blending each pass of a layer takes over the picture, additive for light it adds, normal
+// for a look that covers the team's own.
+function blendingOf(pass) {
+    return pass === 'glow' || pass === 'outline' || pass === 'chromatic' ? THREE.AdditiveBlending : THREE.NormalBlending;
+}
+
+export class Post {
+    constructor(presentation) {
+        this.presentation = presentation;
+        this.layers = [null, null];
+        this.moments = [];
+        this.target = null;
+        this.frame = null;
+        this.quad = null;
+        this.depthOnly = new THREE.MeshBasicMaterial({ colorWrite: false });
+        this.materials = { additive: passMaterial(THREE.AdditiveBlending), normal: passMaterial(THREE.NormalBlending), opaque: passMaterial(THREE.NoBlending) };
+        this.drawn = 0;
+        this.refused = [];
+    }
+
+    // The persistent layer passes of the packages on screen.
+    attach(packages) {
+        this.layers = [null, null];
+        this.moments = [];
+        for (const pkg of packages) {
+            if (pkg && pkg.manifest.post && pkg.manifest.post.layer) {
+                this.layers[pkg.side] = { pkg, spec: pkg.manifest.post.layer, transient: false };
+            }
+        }
+    }
+
+    allowed(pkg, scope, pass) {
+        const p = this.presentation;
+        const quality = pkg.budget.quality;
+        if (pkg.budget.past('noPasses') || quality === 'low') {
+            return 'the team is at a rung without passes or at low quality';
+        }
+        if (p.app.reducedMotion && (scope === 'fullscreen' || DISTORTING.includes(pass))) {
+            return 'reduced motion';
+        }
+        if (scope === 'fullscreen' && (quality !== 'high' || !(pkg.budget.limits.fullscreen > 0))) {
+            return 'a full screen pass needs high quality';
+        }
+        return null;
+    }
+
+    // A pass an effect of type post starts, from a reflex or a worker. A full screen pass plays on
+    // the team's own moment alone, one at a time. Returns whether it was taken.
+    spawn(pkg, spec, c, event) {
+        const scope = spec.scope || 'layer';
+        const refusal = this.allowed(pkg, scope, spec.pass);
+        const own = event && event.team === pkg.side && MOMENTS.includes(event.kind);
+        if (refusal || (scope === 'fullscreen' && (!own || this.moments.some((m) => m.scope === 'fullscreen')))) {
+            this.refused.push(refusal || 'a full screen pass plays on the team’s own moment, one at a time');
+            this.refused = this.refused.slice(-8);
+            return false;
+        }
+        const now = this.presentation.clocks.cosmetic;
+        const duration = Math.min(spec.duration || 1.5, scope === 'fullscreen' ? FULLSCREEN_SECONDS : 30);
+        this.moments.push({ pkg, spec, scope, from: now, to: now + duration, id: c.id });
+        return true;
+    }
+
+    endTransient() {
+        this.moments = [];
+    }
+
+    active() {
+        return this.layers.some(Boolean) || this.moments.length > 0;
+    }
+
+    ensure(renderer) {
+        const size = renderer.getDrawingBufferSize(new THREE.Vector2());
+        const w = Math.max(1, Math.floor(size.x / 2));
+        const h = Math.max(1, Math.floor(size.y / 2));
+        if (!this.target || this.target.width !== w || this.target.height !== h) {
+            if (this.target) {
+                this.target.dispose();
+            }
+            this.target = new THREE.WebGLRenderTarget(w, h, { depthBuffer: true });
+        }
+        if (!this.frame || this.frame.image.width !== size.x || this.frame.image.height !== size.y) {
+            if (this.frame) {
+                this.frame.dispose();
+            }
+            this.frame = new THREE.FramebufferTexture(size.x, size.y);
+        }
+        if (!this.quad) {
+            this.quad = new FullScreenQuad(null);
+        }
+        return size;
+    }
+
+    // Lights light every layer, so the team's own objects keep their light in their own pass.
+    lightLayers(scene) {
+        const now = this.presentation.clocks.cosmetic;
+        if (this.lit && now - this.lit < 2) {
+            return;
+        }
+        this.lit = now;
+        scene.traverse((o) => {
+            if (o.isLight) {
+                o.layers.enable(TEAM_LAYERS[0]);
+                o.layers.enable(TEAM_LAYERS[1]);
+            }
+        });
+    }
+
+    // Draws the passes after the picture, called by the view once it rendered.
+    render(renderer, scene, camera) {
+        const p = this.presentation;
+        const now = p.clocks.cosmetic;
+        this.moments = this.moments.filter((m) => m.to > now);
+        if (!this.active()) {
+            return;
+        }
+        const size = this.ensure(renderer);
+        const governor = p.flashFactor();
+        const passes = [];
+        for (const layer of this.layers) {
+            if (layer && !this.allowed(layer.pkg, 'layer', layer.spec.pass)) {
+                passes.push({ ...layer, scope: 'layer', fade: 1 });
+            }
+        }
+        for (const m of this.moments) {
+            const fade = Math.min(1, (now - m.from) / 0.3, (m.to - now) / 0.3);
+            passes.push({ ...m, fade: Math.max(0, fade) });
+        }
+        const autoClear = renderer.autoClear;
+        const clear = renderer.getClearColor(new THREE.Color());
+        const alpha = renderer.getClearAlpha();
+        const mask = camera.layers.mask;
+        const background = scene.background;
+        renderer.autoClear = false;
+        try {
+            for (const pass of passes) {
+                const env = p.flash.envelope(`${pass.pkg.side}:post:${pass.scope}`);
+                const strength = (pass.spec.strength ?? 1) * env.apply(now, pass.fade) * governor;
+                if (strength <= 0.001) {
+                    continue;
+                }
+                if (pass.scope === 'layer') {
+                    this.lightLayers(scene);
+                    scene.background = null;
+                    renderer.setRenderTarget(this.target);
+                    renderer.setClearColor(0x000000, 0);
+                    renderer.clear();
+                    scene.overrideMaterial = this.depthOnly;
+                    renderer.render(scene, camera);
+                    scene.overrideMaterial = null;
+                    camera.layers.set(TEAM_LAYERS[pass.pkg.side]);
+                    renderer.render(scene, camera);
+                    camera.layers.mask = mask;
+                    scene.background = background;
+                    renderer.setRenderTarget(null);
+                    this.draw(renderer, pass, this.target.texture, 1 / this.target.width, 1 / this.target.height, strength, true);
+                } else {
+                    renderer.setRenderTarget(null);
+                    renderer.copyFramebufferToTexture(this.frame);
+                    this.draw(renderer, pass, this.frame, 1 / size.x, 1 / size.y, strength, false);
+                }
+                this.drawn += 1;
+            }
+        } finally {
+            scene.overrideMaterial = null;
+            camera.layers.mask = mask;
+            scene.background = background;
+            renderer.setRenderTarget(null);
+            renderer.setClearColor(clear, alpha);
+            renderer.autoClear = autoClear;
+        }
+    }
+
+    draw(renderer, pass, texture, tx, ty, strength, layer) {
+        const spec = pass.spec;
+        let material;
+        if (spec.pass === 'custom') {
+            material = this.presentation.customMaterial(pass.pkg, spec.shader, { blending: layer ? 'normal' : 'normal', depthWrite: false });
+            if (!material) {
+                return;
+            }
+            material.depthTest = false;
+            material.uniforms.uLayer.value = layer ? texture : material.uniforms.uLayer.value;
+            material.uniforms.uSceneColor.value = layer ? material.uniforms.uSceneColor.value : texture;
+            material.uniforms.uIntensity.value = strength;
+            if (!layer) {
+                material.blending = THREE.NoBlending;
+            }
+        } else {
+            material = layer ? (blendingOf(spec.pass) === THREE.AdditiveBlending ? this.materials.additive : this.materials.normal) : this.materials.opaque;
+            const u = material.uniforms;
+            u.tSource.value = texture;
+            u.uTexel.value.set(tx, ty);
+            u.uPass.value = PASS_INDEX[spec.pass] ?? 0;
+            const c = Array.isArray(spec.color) && Array.isArray(spec.color[0]) ? spec.color[0] : spec.color || [255, 255, 255];
+            u.uColor.value.setRGB(c[0] / 255, c[1] / 255, c[2] / 255, THREE.SRGBColorSpace);
+            u.uStrength.value = layer ? strength : Math.min(1, strength);
+            u.uLayer.value = layer ? 1 : 0;
+        }
+        this.quad.material = material;
+        this.quad.render(renderer);
+    }
+
+    snapshot() {
+        return {
+            layers: this.layers.map((l) => (l ? l.spec.pass : null)),
+            moments: this.moments.map((m) => ({ side: m.pkg.side, pass: m.spec.pass, scope: m.scope, left: m.to - this.presentation.clocks.cosmetic })),
+            drawn: this.drawn, refused: this.refused.slice(),
+        };
+    }
+
+    dispose() {
+        if (this.target) {
+            this.target.dispose();
+        }
+        if (this.frame) {
+            this.frame.dispose();
+        }
+        if (this.quad) {
+            this.quad.dispose();
+        }
+        this.target = null;
+        this.frame = null;
+        this.quad = null;
+    }
+}

cuju/render/web/js/presentation/preview.js

@@ -0,0 +1,180 @@
+// Copyright 2026 The cuju Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// The preview of a team package, a panel over the match view for authors. It opens with
+// `preview=left` or `preview=right` in the page's address, on that side, as `cuju render pack
+// preview` opens it, with `preview=1` on the side whose package loads, or from
+// `cuju.presentation.preview.open()`. Buttons send events of the package's own team at once, so
+// each reflex and each effect plays on demand, and meters show the team's budgets, the flash
+// governor, the loudness of the master and of each team bus, and the worker's log. The panel
+// reads what `cuju.presentation.status()` gives, which an agent may read the same way.
+
+import { formatNumber, has, t } from '../core/i18n.js';
+import { h } from '../teams/library.js';
+import { icon, symbolOnly } from '../core/icons.js';
+
+export const EVENTS = ['touch', 'pass', 'shot', 'header', 'save', 'slide', 'goal', 'celebration.begin', 'winner.reveal', 'mvp.reveal', 'halftime'];
+const KINDS = ['particles', 'lights', 'localLights', 'shaders', 'voices', 'worklets', 'drawCalls', 'triangles', 'textureBytes', 'geometryBytes', 'audioBytes'];
+
+// The side that the value of preview= in the page's address names, left or right, or null for
+// the side whose package loads, as `preview=1` asks.
+export function previewSide(value) {
+    const v = String(value || '').toLowerCase();
+    return v === 'left' ? 0 : v === 'right' ? 1 : null;
+}
+
+// A number in the page's language with a fixed count of decimals.
+const fixed = (x, digits) => formatNumber(Number(x) || 0, { minimumFractionDigits: digits, maximumFractionDigits: digits });
+const db = (x) => (x == null || !Number.isFinite(x) ? t('presentation.preview.none') : fixed(x, 1));
+const count = (x) => formatNumber(Math.round(Number(x) || 0));
+
+// A word of the contract, a level, a worker's status, a rung or a budget, in the page's
+// language, the contract's own name for one the language lacks.
+function word(group, value) {
+    const key = `presentation.preview.${group}.${value == null ? 'none' : value}`;
+    return has(key) ? t(key) : String(value);
+}
+
+export class Preview {
+    constructor(app) {
+        this.app = app;
+        this.panel = null;
+        this.side = 0;
+        // Whether the side follows the package the page loads, until the viewer picks one.
+        this.auto = true;
+        this.timer = null;
+        const check = () => {
+            const raw = location.hash.replace(/^#/, '');
+            const value = new URLSearchParams(raw).get('preview');
+            if (value && !this.panel) {
+                this.open(previewSide(value));
+            }
+        };
+        addEventListener('hashchange', check);
+        check();
+    }
+
+    // Sends an event of the team on side, at once, to its reflexes and its worker.
+    inject(kind) {
+        return this.app.presentation.inject(this.side, kind);
+    }
+
+    open(side = null) {
+        const p = this.app.presentation;
+        this.auto = side == null;
+        if (side == null) {
+            side = p.packages[0] ? 0 : p.packages[1] ? 1 : 0;
+        }
+        this.side = side;
+        if (this.panel) {
+            return;
+        }
+        const buttons = EVENTS.map((kind) => {
+            const b = h('button', { type: 'button', class: 'bar-btn', 'data-event': kind }, word('event', kind));
+            b.addEventListener('click', () => this.inject(kind));
+            return b;
+        });
+        const close = h('button', { type: 'button', class: 'bar-btn', ...symbolOnly(t('presentation.preview.closeLabel')) }, icon('close'));
+        close.addEventListener('click', () => this.close());
+        const sideButton = h('button', { type: 'button', class: 'bar-btn' }, icon('swap'), t('presentation.preview.otherSide'));
+        sideButton.addEventListener('click', () => {
+            this.side = 1 - this.side;
+            this.auto = false;
+            this.render();
+        });
+        this.body = h('div', { class: 'preview-body' });
+        this.panel = h('section', { id: 'presentation-preview', 'aria-label': t('presentation.preview.label'), class: 'panel',
+            style: 'position:fixed;right:12px;top:64px;width:340px;max-height:80vh;overflow:auto;z-index:40;padding:10px;font-size:12px;background:var(--panel-bg, rgba(16,20,28,0.92));color:var(--text, #eee);border-radius:8px' },
+        h('h2', { style: 'font-size:14px;margin:0 0 6px' }, t('presentation.preview.heading')),
+        h('div', { class: 'preview-events', style: 'display:flex;flex-wrap:wrap;gap:4px;margin-bottom:8px' }, ...buttons),
+        h('div', { style: 'display:flex;gap:4px;margin-bottom:8px' }, sideButton, close),
+        this.body);
+        document.body.appendChild(this.panel);
+        this.timer = setInterval(() => this.render(), 250);
+        this.render();
+    }
+
+    close() {
+        clearInterval(this.timer);
+        if (this.panel) {
+            this.panel.remove();
+        }
+        this.panel = null;
+    }
+
+    // Moves the panel below the offer of the 2D view while the offer shows, which sits in the
+    // same corner of the view.
+    avoidOffer() {
+        const offer = document.getElementById('flat-suggest');
+        const top = offer && !offer.hidden ? Math.round(offer.getBoundingClientRect().bottom) + 8 : 64;
+        this.panel.style.top = `${Math.max(64, top)}px`;
+    }
+
+    // The panel's figures, from the presentation's status.
+    render() {
+        if (!this.panel) {
+            return;
+        }
+        const s = this.app.presentation.status();
+        // A panel opened before the packages loaded follows the side that has one.
+        if (this.auto && !s.packages[this.side] && s.packages[1 - this.side]) {
+            this.side = 1 - this.side;
+        }
+        this.avoidOffer();
+        const pkg = s.packages[this.side];
+        const lines = [];
+        if (!pkg) {
+            lines.push([t('presentation.preview.package'), t('presentation.preview.noPackage', { side: word('side', this.side ? 'right' : 'left') })]);
+        } else {
+            lines.push([t('presentation.preview.package'), t('presentation.preview.packageLine', {
+                name: pkg.name || pkg.team, level: word('level', pkg.level), status: word('status', pkg.status), rung: word('rung', pkg.budget.level),
+            })]);
+            lines.push([t('presentation.preview.mainThread'), t('presentation.preview.ofMs', { used: fixed(pkg.budget.mainMs || 0, 2), limit: fixed(pkg.budget.limits.mainMs, 2) })]);
+            for (const k of KINDS) {
+                if (pkg.budget.limits[k] != null) {
+                    lines.push([word('kind', k), t('presentation.preview.of', { used: count(pkg.budget.used[k]), limit: count(pkg.budget.limits[k]) })]);
+                }
+            }
+        }
+        const none = t('presentation.preview.none');
+        const fx = s.effects[this.side];
+        if (fx) {
+            lines.push([t('presentation.preview.effects'), t('presentation.preview.effectsLine', {
+                instances: count(fx.instances), particles: count(fx.particles), decals: count(fx.decals), lit: count(fx.poolLit), lights: count(fx.poolLights), local: count(fx.localLights),
+            })]);
+        }
+        lines.push([t('presentation.preview.flashes'), t(s.flash.clamped ? 'presentation.preview.flashesClamped' : 'presentation.preview.flashesLine', {
+            general: count(s.flash.counts.general), red: count(s.flash.counts.red), factor: fixed(s.flash.factor, 2),
+        })]);
+        const m = s.audio.master;
+        lines.push([t('presentation.preview.master'), m ? t('presentation.preview.masterLine', {
+            momentary: db(m.momentary), shortTerm: db(m.shortTerm), integrated: db(m.integrated), truePeak: db(m.truePeak),
+        }) : t('presentation.preview.notMetered')]);
+        const bus = s.audio.teams[this.side];
+        if (bus) {
+            const e = bus.meters.effects;
+            lines.push([t('presentation.preview.bus'), e ? t(bus.penalized ? 'presentation.preview.busPenalized' : 'presentation.preview.busLine', {
+                momentary: db(e.momentary), shortTerm: db(e.shortTerm), down: db(e.reduction),
+            }) : t('presentation.preview.quiet')]);
+            lines.push([t('presentation.preview.voices'), t('presentation.preview.voicesLine', {
+                voices: count(bus.voices), music: bus.music.join(', ') || none, processors: bus.processors.join(', ') || none,
+            })]);
+        }
+        lines.push([t('presentation.preview.moments'), t('presentation.preview.momentsLine', {
+            camera: count(s.moments.accepted.camera), time: count(s.moments.accepted.time), environment: count(s.moments.accepted.environment),
+        })]);
+        if (s.moments.refused.length) {
+            lines.push([t('presentation.preview.refused'), s.moments.refused.slice(-3).join(', ')]);
+        }
+        lines.push([t('presentation.preview.passes'), t('presentation.preview.passesLine', {
+            layers: s.post.layers.filter(Boolean).join(', ') || t('presentation.preview.noLayer'), moments: count(s.post.moments.length), drawn: count(s.post.drawn),
+        })]);
+        if (pkg) {
+            lines.push([t('presentation.preview.log'), (pkg.log || []).slice(-5).join(', ') || t('presentation.preview.empty')]);
+            if (pkg.errors.length) {
+                lines.push([t('presentation.preview.errors'), pkg.errors.slice(-3).join(', ')]);
+            }
+        }
+        this.body.replaceChildren(...lines.map(([k, v]) => h('div', { class: 'preview-line' }, h('strong', {}, `${k} `), v)));
+    }
+}

cuju/render/web/js/presentation/protocol.js

@@ -0,0 +1,174 @@
+// Copyright 2026 The cuju Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// The messages between the renderer and a team's worker, section 11 of the contract.
+//
+// The renderer sends a Hello once, then a Frame on every drawing while no reply is outstanding,
+// with the state of the drawings in between coalesced and their events accumulated, never
+// dropped. The worker answers each Frame with a Response that names the Frame's instance, epoch
+// and frame id. A reply of another instance or an older epoch is dropped, and every command in a
+// reply is checked and held to its ranges before it takes effect.
+
+import { checkBehaviour } from './behaviors.js';
+import {
+    checkAudio, checkCamera, checkClaim, checkEffect, checkOverlay, checkResource, checkTime,
+} from './commands.js';
+import { CONTRACT } from './contract.js';
+import { checkTrack } from './tracks.js';
+import { clamp } from './values.js';
+
+// The most commands of each kind one reply may carry, and the largest reply in characters.
+export const MAXIMUM_COMMANDS = 64;
+export const MAXIMUM_REPLY = 512 * 1024;
+// The lines of a worker's log that the page keeps, the newest last.
+export const LOG_LINES = 50;
+
+// The log of a worker with the lines of a new reply added, the oldest dropped past max.
+export function appendLog(log, lines, max = LOG_LINES) {
+    const out = (log || []).concat(lines || []);
+    return out.length > max ? out.slice(out.length - max) : out;
+}
+
+const round = (x) => Math.round(x * 1e4) / 1e4;
+const roundAll = (v) => (Array.isArray(v) ? v.map(round) : v);
+
+// The Hello of an instance, section 11.2.
+export function helloMessage(h) {
+    return {
+        type: 'hello',
+        contract: CONTRACT,
+        features: h.features,
+        lacking: h.lacking || [],
+        limits: h.limits,
+        quality: h.quality,
+        reducedMotion: !!h.reducedMotion,
+        instanceId: h.instanceId,
+        team: h.team,
+        attack: h.attack,
+        roster: h.roster,
+        header: h.header,
+        seedBase: h.seedBase,
+        slots: h.slots || [],
+    };
+}
+
+// A Frame of the protocol, section 11.3, from the renderer's snapshot of one drawing.
+export function frameMessage(s) {
+    return {
+        type: 'frame',
+        instanceId: s.instanceId,
+        epoch: s.epoch,
+        frameId: s.frameId,
+        reset: s.reset || null,
+        clocks: s.clocks,
+        playback: s.playback,
+        quality: s.quality,
+        reducedMotion: !!s.reducedMotion,
+        audible: !!s.audible,
+        players: s.players.map((p) => ({
+            ...p,
+            root: roundAll(p.root),
+            facing: round(p.facing),
+            velocity: roundAll(p.velocity),
+            speed: round(p.speed),
+            distance: round(p.distance),
+        })),
+        ball: s.ball ? { ...s.ball, pos: roundAll(s.ball.pos), velocity: roundAll(s.ball.velocity) } : null,
+        game: s.game,
+        events: s.events,
+        camera: s.camera,
+    };
+}
+
+function list(value) {
+    return Array.isArray(value) ? value.slice(0, MAXIMUM_COMMANDS) : [];
+}
+
+// Checks a reply against what the renderer expects. expect holds instanceId, epoch, own, the set
+// of the team's own entity ids, envelope, a function from an entity id to its conservative bounds,
+// and files, the set of the package's files. Returns {ok, reason, response} with every command
+// checked, or ok false with the reason, stale, foreign or malformed.
+export function checkResponse(message, expect) {
+    if (!message || typeof message !== 'object' || message.type !== 'response') {
+        return { ok: false, reason: 'malformed' };
+    }
+    if (message.instanceId !== expect.instanceId) {
+        return { ok: false, reason: 'foreign' };
+    }
+    if (message.epoch !== expect.epoch) {
+        return { ok: false, reason: 'stale' };
+    }
+    const own = expect.own;
+    const r = {
+        instanceId: message.instanceId, epoch: message.epoch, sourceFrameId: Number(message.sourceFrameId) || 0,
+        ms: clamp(Number(message.ms) || 0, 0, 1e6), resources: [], behaviours: [], tracks: [], effects: [],
+        claims: [], audio: [], camera: null, time: null, overlays: [], bounds: [], log: [], rejected: 0,
+    };
+    const keep = (target, value) => {
+        if (value) {
+            target.push(value);
+        } else {
+            r.rejected++;
+        }
+    };
+    for (const c of list(message.resources)) {
+        keep(r.resources, checkResource(c, expect.files));
+    }
+    for (const b of list(message.behaviours)) {
+        const op = b && (b.op || 'set');
+        const entity = b && b.entity != null ? String(b.entity) : null;
+        if (!b || !['set', 'update', 'stop'].includes(op) || (entity !== null && !own.has(entity))) {
+            r.rejected++;
+            continue;
+        }
+        try {
+            if (op === 'set') {
+                r.behaviours.push({ op, entity, behaviour: checkBehaviour({ ...b.behaviour, id: b.id ?? (b.behaviour && b.behaviour.id) }) });
+            } else if (op === 'update') {
+                r.behaviours.push({ op, entity, id: String(b.id), patch: { ...(b.behaviour || {}) } });
+            } else {
+                r.behaviours.push({ op, entity, id: String(b.id), fadeOut: clamp(Number(b.fadeOut ?? 0.3) || 0, 0, 10) });
+            }
+        } catch {
+            r.rejected++;
+        }
+    }
+    for (const t of list(message.tracks)) {
+        keep(r.tracks, checkTrack({ ...t, source: 'worker' }, own));
+    }
+    for (const e of list(message.effects)) {
+        keep(r.effects, checkEffect(e, own));
+    }
+    for (const c of list(message.claims)) {
+        keep(r.claims, checkClaim(c));
+    }
+    for (const a of list(message.audio)) {
+        keep(r.audio, checkAudio(a, own));
+    }
+    for (const o of list(message.overlays)) {
+        keep(r.overlays, checkOverlay(o));
+    }
+    if (message.camera != null) {
+        r.camera = checkCamera(message.camera);
+        r.rejected += r.camera ? 0 : 1;
+    }
+    if (message.time != null) {
+        r.time = checkTime(message.time);
+        r.rejected += r.time ? 0 : 1;
+    }
+    for (const b of list(message.bounds)) {
+        const entity = b && String(b.entity);
+        const envelope = own.has(entity) && expect.envelope ? expect.envelope(entity) : null;
+        const current = b && b.current;
+        if (!envelope || !current) {
+            r.rejected++;
+            continue;
+        }
+        // Current bounds lie inside the conservative envelope, which framing may always trust.
+        r.bounds.push({ entity, current: { radius: clamp(Number(current.radius) || 0, 0.05, envelope.radius), height: clamp(Number(current.height) || 0, 0.2, envelope.height) } });
+    }
+    for (const line of list(message.log)) {
+        r.log.push(String(line).slice(0, 300));
+    }
+    return { ok: true, response: r };
+}