Hosts and rendering

Game receives start, fixed_update, update, and stop, each with a FrameContext carrying the world, the input state, and frame time, and each able to fail in a way that reaches the host rather than being swallowed. The same loop runs windowed on a desktop, in a browser through the same winit event loop and canvas attachment, and headless in a test.

DesktopApp supplies the window, event loop, and input translation once, so an application does not rewrite them. Target-specific code is confined to the crates that must have it. Application failures retain their complete std::error::Error source chain when logged natively or announced through the browser's sindri:failed event, rather than exposing only the outer host error.

The cube example draws the same picture in Chromium as it does natively, in the same colours, over WebGPU, and games are playable there with Decay executing on the browser target. scripts/browser/smoke.mjs checks that a page starts the engine and fails when it does not.

Adapter, device, and queue negotiation is shared, with conservative cross-target limits, resource labels, and errors that name what failed. Swapchain acquisition has seven outcomes and one policy applied to all of them, so hosts do not re-derive when to skip, reconfigure, or recreate. Surfaces must negotiate an sRGB format or fail loudly. Headless adapter initialisation is proven in CI on software Vulkan.

A frame goes through extraction, preparation, and rendering. Preparation validates and orders passes deterministically by stage, then layer, then insertion order; stage order is Opaque3d, Transparent2d, Overlay.

Gameplay writes to the world and nothing tells the renderer. SceneExtractor derives an ordered frame from whatever the world currently holds, using the built-in camera, mesh, sprite, tilemap, animation, and text schemas. No scene needs hand-written extraction code.

Textures bind by reference: a scene names textures/badge.png, the renderer knows only a TextureId, and one place knows both. An unbound reference draws a magenta checker and is reported by name rather than failing the frame or silently reusing the last texture.

What can be drawn includes a triangle, a coloured cube, and a textured cube with depth testing. The frame clears once before anything draws, so a scene of only sprites has a depth buffer to test against. Perspective and orthographic cameras exist with tested projection maths, and the zero-to-one depth range and Y-up convention are chosen in one place rather than at each call site. Colour space is enforced by a shared constant, and the offscreen capture verifies authored colours actually survive to the pixels. Offscreen rendering produces a deterministic PNG, which CI uploads.

Textured sprites carry tint, anchor, and layer. A sprite is either screen-anchored, which is the default and cannot be occluded by the world, or in the world, drawn through the world camera by its full transform and hidden by opaque geometry in front of it. Sprites batch per space, layer, and texture, with a measured five-to-one draw-call reduction. Each batch draws with its own camera and its own instances, from buffers of its own; a GPU test draws two batches at two scales into one frame and reads back the pixels that only come out right when they stayed separate.

A sliced image says how it is cut, once. A sheet document beside a texture — textures/tiles.png is sliced by textures/tiles.sheet, at a derived ID nothing has to declare — names the parts of it, either as a grid or as explicit rects. A scene then writes textures/tiles.png#floor, and the # that had always been rejected inside an asset ID is what carries the name, because it was reserved so a fragment could not leak into a path. Names rather than indices, so a re-slice that moves a cell does not silently change what a scene draws. Rects are checked once, where a sheet binds, and ride on the instance so every part of one sheet stays in one draw call — a GPU test reads the pixels back to prove the shader honours it. A name no loaded sheet places draws the whole image and is reported by unresolved_sprites, the same rule an unbound texture follows.

A sprite may carry independent RGBA multipliers and offsets evaluated as sample * tint * multiply + offset, travelling per instance so two sprites recoloured differently still share a draw call. The identity is multiply = [1, 1, 1, 1] and offset = [0, 0, 0, 0], so a sprite authored before the transform existed draws exactly as it did. A transform that is not finite is refused at extraction rather than drawn — the reachable case is narrowing, since 1e39 is an ordinary f64 and an infinity once it is an f32 — while a finite value outside zero to one is left alone for the render target to clip. The editor draws the two quadruples as labelled RGBA rows inside an advanced section, collapsed until the scene has authored one and resettable to the identity. Orbital's mine blast flashes white-hot through the colour offset, which a tint cannot do, and cools within a few frames.

Rectangles, ellipses, grids, and regular polygons are evaluated in the shape shader. A polygon may also carry up to eight explicit 2D vertices; those points travel in the same instanced payload and the shader measures against the actual authored edges, so an irregular hull remains crisp without becoming a texture. When no points are authored, regular polygons keep their existing path. The eight-point cap keeps the per-instance vertex attributes inside Sindri's conservative WebGPU limits. Orbital Last Stand exercises the capability with the Strider's exact six-point hull.

sindri.sprite names a .wgsl asset in shader and carries four shader_params. The file defines fn sprite_shader(input: SpriteShaderInput) -> vec4<f32>, handed the pixel as it would draw unshaded, its UVs and the sprite's UV rect, its world position, the four parameters and the scene's clock, with sample_sprite and sprite_texel_size to read the texture again; the engine supplies the vertex stage and pipeline around it. Parameters ride on the instance, so sprites sharing a texture and a shader share a draw. Every host validates a shader with naga as it binds it: the editor loads, watches and hot-reloads the ones a scene names, sindri-player reads them natively and from the export manifest, and sindri-export refuses one that does not compile. A failure names the file and the line in the project's own numbering and the sprite falls back to the built-in look. Decay writes this.sprite.shader_params.{x,y,z,w}. examples/sprite-shaders draws an outline, a dissolve, a hit flash and a wave.

sindri.sprite_mask places a picture whose alpha is a shape, and a sprite with mask: inside or outside and the mask's name draws only within or beyond it, softly where the mask is soft. The mask is batch state read in the fragment stage, so masked sprites still share draws and nothing needs a stencil. examples/sprite-masks reveals a meadow and a hidden gem through a wandering keyhole.

A sprite or UI image drawn sliced keeps the border its sheet records, in pixels by sprite name, and stretches only the middle: nine quads in the image's own space, sharing one draw. border_scale sets how big a border pixel is drawn. The sheet slicer drags the border's guides on the image. The platformer's HUD frame and signboard are one 24-pixel panel.

sindri.animation.sprite holds clips of sprite names and which one plays, SpriteAnimations holds where each sprite has got to, and the cursor holds a name rather than a rect so playback does not depend on where anything sits in an image. Playback is runtime state, so watching an animation run does not rewrite the scene it came from.

Animation.play, stop and restart name one of the clips the scene authored; is_finished, frame and clip read where playback has got to; set_speed scales it. Choosing is authored state and writes the component, so it lives in the world and undoes and saves like anything else, while the cursor is derived and is only read — which is what keeps a script driving an animation from dirtying the scene. play is idempotent so that the natural way to write it (if moving { play("walk") }, named on every frame) runs the clip instead of pinning it to frame one; restart is the separate thing to want.

An animated sprite whose reference names no part of its sheet draws the first frame of the clip it is playing rather than the whole sheet, so a scene shows a pose before anything has run it — in a game's opening frame, in an offscreen capture, and in the editor outside play mode. Once a clip is running it decides alone: a frame that resolves to nothing draws the whole image rather than the resting pose, because a plausible picture of the wrong moment is the failure that hides.

Low Tide exercises speed-controlled clips on children of a moving deck: its two tread belts roll with actual movement, pivot in opposite directions, hold their frame while flooded and resume after the ebb.

Selecting a texture opens it in the Sprite sheet tab, a top-row tab beside the Scene and Game views, where the image fills the canvas pixel-sharp on a checkerboard, zooms about the pointer with the wheel (5% to 6400%), pans with the middle or right button, and fits back with Fit. Each cell is outlined on the picture, named cells are labelled once there is room, and with nothing open the tab lists every image in the project. The slice itself is the inspector's while an image is open: columns, rows, margin and spacing are drags, so a packed sheet with gutters can be cut and not only one that divides edge to edge. A cell is named by clicking it, and the panel lists the cells that have names rather than a field per cell, so a 16x16 atlas is as workable as a four-frame strip. Saving writes the sidecar, and the browser then lists the sprites underneath the image, collapsed until asked for. A sprite's animation inspector creates, renames, and removes clips from those named cells, orders frames, edits timing and looping, chooses the runtime clip, and previews it without changing scene state.

sindri.text is the UI label's fields in world units, placed at its entity and drawn over the sprites of its layer. Decay writes the words with Ui.set_text and Ui.set_number and reaches this.world_text.color. Orbital's landed shots float their damage.

With rich: true, [b], [i] and [color=#rrggbb] tags in either kind of text are spans. Orbital's critical hits float their damage in bold gold.

With lighting_2d on in sindri.environment, world sprites, tilemaps, flecks and world shapes are multiplied by the light reaching them: an ambient color plus every sindri.light2d point light within its radius, faded by its falloff. A sprite opts out with unlit, additive shapes are light themselves, and the UI is never lit. A sprite or tilemap may name a normal_map laid out like its texture; a light's height then decides how squarely it meets each texel, so a low light rakes across the relief. A light with shadows on is blocked by sindri.light2d.occluder boxes, polygons and the solid cells of a tilemap, through one-dimensional polar depth maps built on the CPU each frame. An optional five-sample area light produces approximate soft shadows; Lamplighter uses it for its lanterns. Decay writes a light's color, intensity, radius, falloff and height. The Scene view draws light radii and occluder outlines with handles. The platformer's cave is the proof. A voxel world viewed as a map is lit too, and its normal_maps name a normal map for each texture its squares draw from: Low Tide's Basin is lit by a sun that follows the tide from noon through a golden hour to a moonlit flood, and its crawler carries lamps and shadow-casting headlights.

The responsive browser studio uses the same generation library and saves PNG and settings files; its lighting preview is approximate. The editor Normal map tab derives a sprite's normal_map from its brightness or a painted height map, keeping its size, alpha and pixel edges, with each sheet cell kept apart, and material presets as starting values. The preview is the game's own 2D lighting rather than an imitation: the studio's surface, light and ambient are a sindri.sprite, a sindri.light2d and a sindri.environment in a world of its own, extracted and drawn as the Scene view draws, and a test requires the frame to equal the one a scene using the saved map extracts. It shows the map per channel, splits it against the sprite lit without a map, and orbits a plane in 3D. Saving writes the map and a .normalmap of the settings, so the map is made again from changed art; the platformer's hero is lit through one made this way.

A tilemap is a grid of tiles drawn from one entity: sindri.tilemap carries the map's grid, a palette of sprite names, and a flat array of cells indexing that palette, with null where the map is empty. Its cells become instances in the same batches loose sprites use, so a prop sorts among the floor rather than behind it. Columns and rows lay out orthogonally or isometrically, and placing a tile and finding the tile under a point are inverses on every cell of both.

Selecting a world-space tilemap shows the slices from its texture's sheet as a visual palette, lets its grid be resized while preserving the overlap, and turns primary drag in the Scene view into an undoable paint or erase stroke. The hovered cell is found by inverting the exact camera matrix used to render that viewport, so an orthographic or isometric map does not need separate picking approximations. The ordinary component fields still edit projection, tile size, tint, render layer, and space.

A sheet can declare terrains: the sixteen edges or forty-seven blob sprites a cell draws for each pattern of same-terrain neighbors. The tilemap brush and Grid.set_terrain paint a terrain and redraw every neighbor whose picture depends on the cell, erasing included. The platformer's level is painted with its ground terrain.

A corners terrain is sixteen sprites chosen by which of a tile's four corners are the terrain, the layout of a Wang or Tiled corner set. It is painted by corner: Grid.set_terrain_corner sets or clears the corner at a grid line's crossing and rewrites the up to four tiles that meet there, each reading its own corners back from the sprite it already shows. This was found by trying to use the first tileset Pixel Lab generated for Lamplighter, which is laid out this way. Lamplighter's ground is that tileset: scripts/ground.decay lays its dirt path corner by corner, and a test reads the tiles back.

sindri.tile_grid carries the geometry — columns, rows, cell size, projection, and the screen step one level costs — and sindri.tile_volume carries sparse cells at integer (column, row, level) coordinates naming tiles in a reusable .tileset asset. Empty is absence rather than a reserved ID, so an empty sky costs nothing to store. A tile says what its faces look like, whether it hides a neighbour's shared face, whether it is solid, and how much of its cell it fills; the renderer resolves each occupied cell into only the faces nothing covers, so a column two blocks taller than its neighbour exposes two side faces without a cliff case and removing a lower block opens a real hole.

A tile can be shorter than its cell. height is a fraction of a cell measured from its floor, defaulting to one. A half is a slab. The value is logical: it decides what the tile hides and how high something standing on it stands, and says nothing about the art. Anything taller than one cell is refused when the asset decodes, because occlusion and occupancy both assume a cell's contents stay inside it. A neighbour hides a side face only when it is at least as tall as the face it abuts, and a top face survives a block placed above it unless the tile fills its cell.

Both projections are real. orthogonal or isometric decides where a cell sits, which of its faces a view can see, and what "behind" means. One tile set serves both: faces a projection cannot see are left undrawn. Depth belongs to a cell's column rather than to each drawn face, so a tower keeps the depth of the column it stands in.

Runtime tile volumes have one engine-owned chunk unit. A chunk is 16×16 columns, addressed with Euclidean coordinates and held sparsely by TileChunkStore; materializing it produces the existing scene component.

A volume is resolved once, not every frame. It is resolved into faces once and replayed, with only the depth each cell sorts at measured again. World gives each entity a revision, bumped whenever anything takes a mutable borrow of it, and TextureBindings and TileSetBindings each carry a generation, handed out process-wide; a volume keeps the ones it was built from, so editing its cells, moving it, changing its grid, rebinding its tile set and re-cutting its atlas each show up on the next frame. baked_volume.rs is one test per input: each edits exactly one of them and fails if the volume goes on drawing what it drew before.

A script reaches one cell at a time. Grid.block(volume, column, row, level) answers with the tile a cell holds and Grid.set_block writes one, with the empty string meaning absence in both directions. A write naming a tile the volume's own tile set does not define is refused at the call.

A volume is three-dimensional and grid navigation is not, so the bridge is a surface: for each column, the height of the ground something walking across it stands on — the top of its highest solid cell, which is a fraction rather than a level because a slab's top genuinely sits half a cell lower than a block's. A column holding nothing solid has no surface at all: it is a hole. Every edge between two columns is then either a step something can take or one it cannot, and sindri-grid already refuses to cross a blocked edge — so the volume becomes walls rather than the pathfinder learning about levels. sindri.grid.navigation carries max_step, one cell by default.

A grid still carrying sindri.tilemap navigates by that flat map alone, so dropping a volume beside an existing floor never closes ground the game already walks on. Only WorldGridNavigation::from_world_with_tile_sets can answer at all, because which cells are solid and how tall they are is a question only the tile set answers.

Grid.walkable(floor, x, y) answers whether a walker can stand where a point falls, from the walkable surface the pathfinder walks, choosing the cell by sindri_scene::nearest_cell, the same rule a walker's own placement reads from. Off the grid, water, decoration and empty columns all answer the same way. An authored occupant rests on whatever supports it; a walker stands only on what is walkable.

sindri.environment is authored scene state for background, ambient fill, directional shadows, voxel contact-depth ambient occlusion, and an ordered world post stack. The sun is a sindri.light entity (kind directional) aimed by its rotation along local -Z and drawn and aimed in the Scene view; SceneExtractor::lighting combines it with the environment's ambient into renderer-owned WorldLighting, tolerating an invalid light in the editor; textured cubes, authored meshes, and cached voxel meshes share that model in editor and browser rendering. The default renderer lighting preserves the previous unlit appearance for scenes without an environment. Voxel Lab is the acceptance surface. Directional shadows use one bounded depth map with authored coverage, 256–2048 resolution, and bias controls; both transient world meshes and persistent voxel meshes cast and receive them.

this.light and Entity.light expose color, intensity, range, spotlight half-angles and independent boolean enabled state from the shared typed surface. Setters validate full candidates before mutation, including f32 narrowing and cross-field cone bounds; failed writes retain payloads and whole colors are atomic. Reads honor omitted defaults; Color alpha stays one. The enabled flag changes illumination without deactivating the entity or stopping its scripts. examples/lighting3d is feature proof for Explorer's planned lighting track: its checked script animates parented points/spots and the sun, reaches lit/dark Session goals and exercises cube, inline and imported geometry. Completion, hover, generated docs and typed batch checks share the same metadata. Native, real WebGPU and editor Play controls are recorded in 3d-lights.md. In-tree game adoption and local shadows remain open; no new uniform or pass cost is introduced.

SceneExtractor::world_settings gathers an environment's light, shadows, fog, occlusion strength and grade into one WorldSettings, and TexturedCubeRenderer::configure applies them, so the shared native/browser player and the offscreen project renderer light a frame as the editor does. A frame with post-processing goes through encode_lit_frame and its bloom. Causeway ships tone mapping, grade, vignette and bloom on its lanterns and beacon this way. Decay reaches the same settings while a game runs: this.environment.fog, .post_process and .bloom read and write each field, checked as the scene's own values are, and Causeway eases every island's fog, grade and bloom from one mood to the next, flashing them for lightning.

ModelAssetDecoder parses self-contained binary GLB into reusable CPU geometry, node local matrices/children, materials and embedded base-color textures. The tiny deterministic fixture exercises both index widths, multiple primitives, mesh reuse, non-indexed triangles and malformed/unsupported diagnostics. AssetLoader reuse is covered. A separate renderer resource and GPU path retain normal/UV geometry, hierarchy, textures and materials, composing node and entity matrices with inverse-transpose normals. GPU readback coverage checks colors, depth and upload reuse; renderer resource tests check malformed data. Scene ModelComponent references validate asset paths and extract shared resources with entity world transforms. Disabled models are discovered without drawing; missing bindings name the asset. The public facade converts decoded models without cross-coupling foundational crates. The editor catalogue assigns the registered component an existing icon/family. Render and static-collision asset fields now declare model metadata, use a GLB-only project picker and complete Add Component with an actual model. Independent widget/component history scopes keep the two selections separate; native review verifies Undo/Redo, save/reopen and Play with an alternate wall. Broader model authoring remains deferred. Model manifests and export retain original GLB bytes and discover scene/prefab references, including inactive entities. Native project capture and the WebGPU project host prepare/bind models once through the existing asset queue and apply scene lighting. The exact Low Tide cutaway crawler was visually inspected in both runtimes at 1200 × 1000, correctly oriented and visibly recognizable. Exported bytes match the source hash. Full editor authoring, animation and skinning remain deferred. This external proof does not claim the repository's in-tree game completion surface. Model Collision Lab now also has native player-window visual proof on X11/software Vulkan, after editor asset selection and save/reopen; the imported wall blocks keyboard movement and the walker renders on the goal pad. Causeway draws every island, figure and building as a generated GLB with emissive materials, lit by the sun and point lights. See imported models.

examples/orbit is an authored feature project with a walker, raised goal and blocking wall. Decay changes the perspective FOV and orbit angles; the shared runtime follows, aims, pulls in against the wall and recovers after the wall is disabled. Its project test opens, compiles and runs to the goal. Native and exported Chromium captures were visually inspected before and after recovery; the browser fetched the exported assets and reported the scripted goal without runtime or GPU errors. The flat-color example produces fourteen screenshot colors, so its local smoke used an eight-color minimum plus blue-walker and gold-goal pixel checks instead of the generic sixteen-color blank-frame gate. Scene regressions cover immediate pull-in, smoothed recovery, sensor/layer/self filtering, rotated and scaled parents, Z locks, invalid settings and payload preservation. Editor Add Component now creates Camera Orbit from a real active spatial target with a stable ID; a Camera is required. Invalid numeric or target edits are refused before commands, retaining the previous component. Unit tests exercise defaults, self/child/inactive/UI/unidentified exclusions, validation, Undo/Redo and save/reopen. Native review removes the camera script from a scratch Orbit Camera Lab, authors orbit in the inspector and reaches the walker goal with engine-owned pull-in/recovery. Selected Scene view guides show the world-space focus, requested position/yaw circle and actual camera pose during pull-in/recovery, with near-plane clipping and no picking or world mutations. Parented target/owner, live poses, invalid targets, overflow and a camera behind the Scene eye have regressions. Collision uses one sight-line ray and synchronized obstacle poses; camera-volume sweeps and Explorer's game/browser proof remain pending. Pointer lock has separate native, browser and editor feature-lab evidence. This is new general camera capability for Explorer in slice 6 of docs/3d-update.md.

Orbit Lab also exercises existing transform scale through normal keyboard controls: 1 narrows the wall, 2 restores it and R resumes automatic removal. Manual edits reactivate and retain the barrier. A synchronized center ray must hit it before an outside ray can verify the narrow/wide state, preventing an inactive/missing collider from counting as scale proof. Session regression observes reactivation, repeated edits, orbit recovery/pull-in and the goal; Chromium drives the same controls and captures both widths. Native scale review verifies matching mesh/collider guides, Undo/Redo, save/reopen, Play queries/goal and Stop restoring the saved scale. This is feature adoption of the existing general 3D scale capability; Explorer game proof remains open.

Shared MaterialFactors and direct GGX now shade opt-in cubes, inline/cached meshes, voxel roots and imported primitives. sindri.material authors linear base color, metallic/roughness and emission, with checked ranges and per-entity factor replacement. GPU comparisons, zero-light emission, mask-alpha and cache reuse, scene undo and voxel residency regressions, native/browser swatches and native editor edit/Undo/Redo/save/reopen review exercise the numeric foundation. Core GLB emissive factors survive decoding/preparation and render without scene overrides. Decoder/facade/resource tests, zero-light GPU readback, override restoration, masked-shadow invariance and native/browser imported GLB controls exercise this addition. Absent overrides preserve legacy/imported looks. Material texture-bearing assets, unified alpha, emissive maps and Explorer game adoption remain open; see the material contract.

Cubes carry outward face normals, while inline mesh documents and cached render vertices can supply object-space normals for smooth lighting. Checked components reject malformed vectors/counts; absent normals retain flat shading. GPU comparisons with imported geometry exercise nonuniform scale, rotation and reflection; world color/shadow pipelines correct reflected front-face selection. Scene edit/history tests and native/browser smooth/flat ellipsoid controls prove the feature. Textured vertices grow from 24 to 36 bytes; per-draw uniforms and cache residency are unchanged. Editor authoring review, Decay access and Explorer adoption remain open. See normal semantics.

this.light and Entity.light expose color, intensity, range, spotlight half-angles and independent boolean enabled state from the shared typed surface. Setters validate full candidates before mutation, including f32 narrowing and cross-field cone bounds; failed writes retain payloads and whole colors are atomic. Reads honor omitted defaults; Color alpha stays one. The enabled flag changes illumination without deactivating the entity or stopping its scripts. examples/lighting3d is feature proof for Explorer's planned lighting track: its checked script animates parented points/spots and the sun, reaches lit/dark Session goals and exercises cube, inline and imported geometry. Completion, hover, generated docs and typed batch checks share the same metadata. Native, real WebGPU and editor Play controls are recorded in 3d-lights.md. In-tree game adoption and local shadows remain open; no new uniform or pass cost is introduced.

sindri.light now supports point lights with world-unit range. The strongest eight active points shade primitive, inline/cached/voxel and imported geometry through shared Lambert/GGX point lighting. Positions follow composed live transforms and inactive ancestors suppress the light. Editor creation uses one checked transaction and selected world-range circles; studio lighting omits authored points. Native/browser feature controls and GPU/scene regressions are described in the 3D light contract. This is Explorer feature proof, with no in-tree game adoption yet; local shadows are absent. Typed runtime light properties are described below. Points now share the spotlight records described below. The fixed uniform cost is 512 additional bytes per color draw; shared buffers and spatial light assignment remain open.

Explorer's planned lighting track now has unshadowed spotlights as feature proof; no in-tree game uses them yet. sindri.light.kind = "spot" uses composed world position/forward with validated inner/outer half-angles in radians. Points and spots share eight strongest-intensity slots, range falloff and Lambert/GGX shading across world/voxel meshes and imported models. Cone strength feathers with smoothstep between angle cosines. Color uniforms are now 880/944 bytes for textured/model draws (eight 64-byte light records, plus the model silhouette color); shadow uniforms, passes, writes and persistent geometry uploads are unchanged. The editor creates down-facing spots in one undo step and paints clipped selected inner/outer range cones. Native/browser aimed/away controls and Scene/GPU/guide regressions provide feature evidence. Local shadows and Explorer adoption remain open; runtime light controls and mounted-light feature evidence are described below and in 3d-lights.md.

Typed this.environment / entity.environment address an existing authored environment. Ambient intensity, RGB Color and RGBA background reads honor defaults; writes validate the full payload before mutation and preserve unrelated settings. Whole Color writes are atomic, fractional numbers stay fractional, ambient alpha stays one, and stale/missing targets are runtime errors. Lighting Lab extends its first two phases with cool/warm ambient and clear-color changes, restoring original settings at the ready goal. Shared Session tests observe the resulting lighting and frame clear; native/browser captures and editor Play exercise rendering. This is feature proof for Explorer/Low Tide 3D's planned lighting track, with in-tree game adoption and fog/post controls open. Day/Night Lab below exercises the project clock and mounted-light integration. No renderer layout, resource lifetime or dependency changes. See runtime-environment.md for the contract and validation evidence.

examples/daynight is feature proof for Explorer and external Low Tide 3D's planned lighting track. Its Decay-owned clock smoothly changes sun brightness, color and rotation, ambient light and background through four phases. A moving GLB carries a point and spotlight; night illumination works while the sun is disabled. Real-project Session tests exercise two clock configurations, all phases, composed night positions, continued motion after the goal, frozen hours and independent night controls. Native/browser images isolate moving sun shadows on imported ground with fixed model poses, and local illumination at midnight. Native editor Play runs the same scene. See daynight.md for measured evidence. No new host API, renderer path, dependency or engine time service; in-tree game adoption and fog/post controls remain open.

Scene extraction reuses immutable geometry until its positions, UVs, normals, indices or atlas rectangle change. Per-renderer weak caches upload once across shadow/color draws and retire unused resources; older frames own their revision. Checked edits/undo, lifecycle, real u32 drawing and shared shading have regressions. Native/editor benchmark reports record zero settled geometry uploads with unchanged draws/passes. Release browser exports exercise real u32 geometry, shadows, smooth normals and live lighting. This is feature proof for the planned Explorer/Low Tide 3D track; in-tree game adoption, instancing, deduplication and culling remain open.

The material component carries a checked sidedness choice independently of numeric factors. Inherit preserves imported primitive settings; other geometry is single-sided. Explicit single/double choices govern both color and shadows, including reflected transforms and lighting on visible backs. Policy edits retain geometry and voxel meshes. Lighting Lab carries a back-facing orange panel and a single-sided native/WebGPU control. Shared texture bindings, alpha unification and Explorer game adoption remain open.

Engine-owned render_material profiles carry checked numeric factors and sidedness. References use the existing asynchronous profile pipeline and export dependency walk, including inactive entities, later scenes and expanded prefabs. Explicit local overrides are independent of profile values. Invalid editor reloads retain last-valid values; extraction snapshots values without replacing geometry. Lighting Lab shares three profiles across six objects and carries inline-equivalence and shared-edit controls, exercised in native and real Chromium/WebGPU captures. Native editor review covers creation, selection/history, validated Save/correction, reload, reopen and Play. Material texture ownership, unified alpha and in-tree game adoption remain open.

sindri.model.occluded_color opts into a depth-tested flat RGBA pass. Opaque non-subject geometry fills depth first, then silhouettes, then normally lit subjects. Shared geometry, material facing and cutouts are preserved. No subject self-occlusion; opted-in subjects do not reveal each other. Filled silhouettes may accumulate alpha where primitives overlap; transparency can cover them. JSON authoring only; editor color interaction is not proven.