Commit Graph
100 Commits
Author SHA1 Message Date
Sameh Khamis 7b07ddeefd Cesium imageryFrames: a timed-out seek is not drawn as done, and a failed video is not kept
After a seek timed out its video already had the target time, so the next
frame skipped seeking and drew whatever showed as a finished tile; a video
still seeking is now seeked again. The seek past its end that learns a
video's length waits 60 s, not the 10 s of a frame's seek, and a video whose
load or length probe failed is dropped, so the next frame starts over
instead of failing until the video is evicted.
2026-11-11 20:03:20 -08:00
Sameh Khamis b3c6f35023 Cesium: a blob's object URL is revoked once the blob is collected, not by time
Revoking a URL idle for a minute broke two things: the icon atlas, keyed by
URL and never freeing a slot, took a new slot each time a blob was drawn
again until it had no room; and an image material, which loads on its first
draw, made hidden and shown later fetched a revoked URL and never drew. A
blob now keeps one URL, revoked by a FinalizationRegistry once the blob
itself is collected: anything that can still draw it holds it.
2026-11-11 20:02:20 -08:00
Sameh Khamis db80c9f141 Stub setBase: imagery is added before photoreal is awaited
An unawaited setBase with photoreal and imagery, followed by another,
added its imagery after the later call had set its own, leaving both.
The imagery now goes in before anything is awaited, as the Cesium port
adds it, and an overtaken call resolves settled: false.
2026-11-11 20:01:20 -08:00
Sameh Khamis ca82e23d94 Conformance: clamped rims and walls are picked; the vector base covers string stops, no background and its restore
draw.shapes.clamped picked only the outlined rectangle and the extruded
ellipse; it now also picks the outline-only rectangle on its rim and the
wall on its face, seen from the south. The stub picks both: a clamped
outline along its ring as a draped line of its outline width, a wall where
its panels cover the pixel.

globe.base.vector also draws roads whose join and cap are legacy zoom
functions of strings, checks that a style with no background shows the
globe through rather than black, and ends by switching to a base without
the vector style, which must draw none of it and drop its credit.
2026-11-11 19:39:26 -08:00
Sameh Khamis 748dc0a156 Cesium: revoke blob object URLs no longer drawn
The object URL store keeps its blob alive, so a blob image's URL, never
revoked, kept every blob ever drawn. A blob's URL is now revoked once it has
not been asked for in a minute with two frames drawn since (so a material,
which loads in the next frame, has started its load); images already
loading or loaded are unaffected, and a blob drawn again gets a new URL.
2026-11-11 19:34:43 -08:00
Sameh Khamis a3ffb33563 Cesium imageryFrames: frames waiting on a tile video let go fail
An evicted (or cleared) tile video is emptied, so it never loads or seeks
again, and every frame queued on it waited forever, leaving its tiles
never finished. Letting a video go now fails what waits on it, and a seek
that does not end within 10 s fails its frame.
2026-11-11 19:30:31 -08:00
Sameh Khamis 9d3e99c831 Cesium draw: a clustered icon set clusters again after setColumns
The wrapper that marks a clustered set for clustering again ran before
setColumns was assigned, so column changes never reclustered; with no rows
moving, positions or shown written by columns left the old clusters drawn.
setColumns is now assigned first and wrapped with the rest.
2026-11-11 19:29:04 -08:00
Sameh Khamis 750dab0123 Cesium vectorBase: transparent where the style paints no background; cancelled tiles not painted
The provider said it had no alpha channel, so a style with no or a
translucent background drew black there. And its requestImage ignored the
Cesium request, so tiles of a removed layer were still painted once their
source tiles arrived; a cancelled request now aborts the paint.
2026-11-11 19:28:13 -08:00
Sameh Khamis 09d1133d90 vectorBase: evaluate as the style specification does; leave out features with no value
- A legacy function without a type is exponential only on a property that
  interpolates and interval on any other (line-join, text-transform, ...);
  a property function with string outputs is no longer categorical.
- step over what is not a number fails, leaving the feature out.
- has, get and legacy filters see a feature's own properties, never
  inherited names such as toString.
- A value that comes to null, undefined or NaN leaves the feature out
  instead of being written to the canvas, which ignored it and drew the
  last feature's colour or width.
- A layer's labels are placed in their features' order, as MapLibre
  places them, not reversed.
2026-11-11 19:27:33 -08:00
Sameh Khamis 72d8dd606d setBase: the last call wins; an overtaken or disposed one changes nothing
A vector setBase awaited its style before changing anything, with no
generation guard, so a slow earlier call landed over a later one, and one
in flight at disposal rejected. Cesium and the stub now count calls like
setPhotoreal and setTerrain, abort the overtaken style load, and resolve
an overtaken call with imagery: [] and settled: false.
2026-11-11 19:25:04 -08:00
Sameh Khamis 5fae3cf485 Draw vectorBase: a MapLibre style's vector tiles painted as imagery
src/render/vectorBase/ is a Cesium-free painter: loadVectorStyle loads
a style and its TileJSON sources and compiles its layers (skipping, with a
reason, what it does not draw), and paintVectorTile paints a Web Mercator
tile on a canvas: background, fill, line and circle layers with filters in
both syntaxes, legacy functions and a listed subset of expressions, and
symbol text labels placed clear of each other inside the tile. Sources are
decoded with pbf and @mapbox/vector-tile, already dependencies. The Cesium
port loads the style before changing the base, draws it as Web Mercator
imagery under the base's other imagery, credits its sources, and claims
vectorBase; the stub loads the style. globe.base.vector serves a style and
tile from data URLs and reads the drawn fill.
2026-11-11 18:24:49 -08:00
Sameh Khamis d9ad7da9d5 GPU icon sets cluster their rows where their segments put them
clusterScreenPoints over each GPU set's shown rows at the frame's
motion-clock time (on their ground when clamped), the members' rows hidden
and one icon a cluster drawn at its seed's size in the set's cluster
billboards, picked as each member. Clustered again after the camera moves
or the set changes (setColumns included), and every frame while rows still
move. Conformance checks take several capabilities; draw.motion.cluster
clusters members that come to rest on their segments.
2026-11-11 18:09:38 -08:00
Sameh Khamis 933969b7da GPU icons draw offsets, anchors, rotations, fades, display ranges and clamped heights
Each row reads its extras from a float texture by instance (texelFetch on
gl_InstanceID), so the 16 vertex attributes hold: pixel offset, vertical
anchor, screen rotation and aligned axis (turned as billboards turn),
fadeByDistance, displayRange, and a ground mode with the heights under its
segment's two ends. Clamped rows are sampled after a frame draws, budgeted
across the port's sets (terrain first, then the drawn surface), and again
when the globe's tiles finish loading. WebGL 1 still refuses these; GPU sets
still refuse clustering. The stub picks icons offset, anchored, turned and
clamped to its ellipsoid, and draw.motion.look checks each on a moving icon.
2026-11-11 17:58:40 -08:00
Sameh Khamis 759308404e draw.motion.live measures from the wall time it drew at
The icon moves past its own width in about a quarter of a second, and a
new renderer's first frame can come that late: the check now reads where
it should be from the wall time after that frame, its delay and its
'not at wall time' unchanged.
2026-11-11 17:33:52 -08:00
Sameh Khamis a043854f27 Timed imagery reads the drawn globe tiles through internals.js
The tiles the globe last drew are a private Cesium field: read through
globeTilesDrawn, whose field the internals test checks the installed
Cesium still declares.
2026-11-11 17:20:58 -08:00
Sameh Khamis ee9de4edda Image fills pulse on the Cesium renderer
A shape with an image fill and animate is no longer refused: the fill's
alpha pulses through its image material's colour, on the surface or
clamped, as colour fills pulse.
2026-11-11 17:16:21 -08:00
Sameh Khamis 20138cb313 Wind streamlines over part of the globe on the Cesium renderer
A windStreamlines grid short of 360 degrees of longitude is no longer
refused: the paths seed inside its rectangle, equal-area, and stop at its
edges. The baker takes the rectangle as optional bounds; a grid round the
globe bakes as it did.
2026-11-11 17:14:56 -08:00
Sameh Khamis 1cc9c45418 Draped lines in the sky's frame on the Cesium renderer
A draped line in the inertial frame is no longer refused: it is held as
given, drawn turned into the fixed frame where its motion clock has the
sky, and draped again each second of that clock, the old ground line
kept until the new one is ready.
2026-11-11 17:12:55 -08:00
Sameh Khamis 9995b35874 Clamped shape outlines pulse on the Cesium renderer
A clamped outline with animate is drawn with a colour material, its rings
sharing one colour, and pulses its alpha through it each frame as the
shape's fill does.
2026-11-11 17:10:30 -08:00
Sameh Khamis 6ec4d5571d Every Cesium draw set takes columns
Sets other than icons take setColumns as the rows the columns make over
the items they hold, replacing every item as set does, as the stub does,
so renderer.shape holds on Cesium and joins its checks.
2026-11-11 17:08:09 -08:00
Sameh Khamis a356d094d5 Timed imagery on the Cesium renderer (imageryFrames)
A layer given a timed source hides its own imagery and draws the frames
its clock shows (the scene's time, or setFrameTime on its own clock) as
Cesium layers just above it: the nearest frame, or in blend mode the later
over the earlier at its share of the way, with the next prefetch frames
loading unseen at alpha 0. Video segments are seen every 250 ms, each tile
its video seeked to the time's share of its length. frameReady names the
nearest frame once every globe tile drawn shows its own imagery. The
check globe.imagery.frames now runs on Cesium, and globe.imagery.video
draws a recorded video's frames.
2026-11-11 17:06:33 -08:00
Sameh Khamis b741b0d5f5 Every set blends as its blend says on the Cesium renderer
Each frame drawn, a set's host turns the draw commands it gave to the set's
blend before the scene sorts them: opaque draws every command in the
opaque pass unblended with depth writes; translucent alpha-blends every
command without depth writes; additive adds colour times alpha without
depth writes, still depth-tested, after the opaque commands and before the
order-independent translucent pass. Ground commands only blend
differently. Lines, shapes, models, quads, meshes and GPU icons take every
blend, live through setOptions (models do not load again); GPU icons no
longer refuse opaque or additive. The contract documents the semantics and
the checks draw.sets.blend and draw.models.blend read the pixels. The
package boundaries own setBlend.js and screenCluster.js.
2026-11-11 16:49:27 -08:00
Sameh Khamis a4a4366b13 Icon sets cluster on the Cesium renderer
Clustered icon sets cluster with clusterScreenPoints over the shown icons
each frame drawn after the camera moves or the set changes. A cluster draws
one icon (icon(count), else a count badge) at its members' mean in place of
the members; a pick on it answers each member, seed first, at the cluster's
position. GPU icon sets refuse clustering. The stub clusters the same way,
the contract documents the semantics, and the check draw.icons.cluster
covers it.
2026-11-11 16:33:21 -08:00
Sameh Khamis d497435b61 Cesium shapes: clamped outlines, clamped extrusions and walls, image fills without draping
Clamped outlines were refused; they are now draped lines, a ground polyline
a ring (a polygon's rings, an ellipse cut in 64, a rectangle's turned
corners) under the shape's pick id. Clamped extruded shapes, clamped walls,
and clamped image fills where the scene has no depth textures were refused;
they now stand on the surface unclamped, the surface height read when the
set is built (an extrusion from the lowest point under it, a wall's foot
under each position). The new conformance check draw.shapes.clamped draws
each kind; Cesium runs it.
2026-11-11 16:17:28 -08:00
Sameh Khamis 19055b2b8b Cesium lines: segments on every mode and style, draped patterns, inertial depth-fail
Segment colours and shows were drawn on draped solid lines only. Any other
segmented line (3D, geodesic or draped; glow, dash, arrow, flow, pattern or
an outlined solid) now draws a primitive a segment, each with its style's
material in the segment's colour under a pick id that reads as the line's,
recoloured and shown in place; an arrow's head is on its last segment, and
a revealed line shows each segment by its share of the length. Draped
pieces swap in with the set's other ground primitives. Pattern lines drape
on a ground polyline of their own, and an inertial line with a depth-fail
style is a primitive turned with the sky each frame. The new conformance
check draw.lines.segmentStyles picks shown and hidden segments of five
mode and style pairs before and after an in-place change; Cesium runs it.
2026-11-11 16:13:56 -08:00
Sameh Khamis c7bb08bfb4 GPU frame timing on the Cesium renderer, where timer queries exist
With EXT_disjoint_timer_query_webgl2 the Cesium renderer lists gpuTiming:
while frame signals have listeners, each drawn frame is timed from preRender
to postRender and a signal carries gpuMs of the newest timing back (a
disjoint one is dropped); queries are reused and let go on dispose. Without
the extension it answers 'none', as before. The new conformance check
quality.signals.gpuTiming pins both; the stub's timed frames carry 0 ms.
2026-11-11 16:00:37 -08:00
Sameh Khamis 8122199887 The Cesium renderer lists modelAtmosphere
Cesium's models already take the atmosphere's scattering, in the stage that
draws distance fog; the capability now says so, and the contract doc says
it follows the sky's fog setting there.
2026-11-11 15:56:50 -08:00
Sameh Khamis d249ef24eb The Cesium renderer lists followAutodetect, and a conformance check pins it
An autodetect follow already rode Cesium's AUTODETECT tracking frame; the
capability now says so. The new check camera.follow.autodetect follows a
still target (range kept, its frame east-north-up on it) and one at orbital
speed (range kept frame by frame, its frame on the target with z up); the
stub and Cesium both run it.
2026-11-11 15:56:22 -08:00
Sameh Khamis 71f0945635 Every image kind draws on the Cesium port, atlas slots wherever an image is taken
Icons on billboards and on the GPU, line patterns, shape fills, quads and
raster shells take a URL, SVG, a blob (one object URL per blob), a keyed
canvas (packed into the GPU icon atlas as it is, by its key) and an atlas
slot as the image it holds. Blobs and canvases were refused on the GPU
path, blobs on billboards, and atlas slots everywhere but billboards. The
new conformance check draw.icons.images draws each kind on still and
receding icons; Cesium runs it.
2026-11-11 15:55:27 -08:00
Sameh Khamis 0e8be0fb78 Icons turned about an axis stand along it on the Cesium port's billboards
rotationMode 'axis' was drawn upright: the item's alignedAxis now becomes
the billboard's (normalised), and a changed axis restyles it in place.
2026-11-11 15:52:56 -08:00
Sameh Khamis b2ca9a7d3c Renderer contract doc: what a renderer does, by role
Documents ROLES and roleOf: a renderer is a whole globe engine, the
application keeps the data, and every member of PORTS sits in one of six
roles.
2026-11-11 15:04:38 -08:00
Sameh Khamis ffbd9fe4c2 Weather: an empty frame tile whose encode failed is encoded again
The shared transparent tile kept a rejected encode, so every later empty
tile failed with it. A failed encode is now dropped and the next empty tile
tries again.
2026-11-11 14:29:35 -08:00
Sameh Khamis 46ad53aa35 A renderer's roles: per-layer lighting is part of the look, and roleOf knows only real members
imageryLayer.lit (a layer shaded by the sun) joins the look with surface
shading. roleOf answers undefined for a member its port does not have, and
the port's own role without a member. The test now fails when two roles
claim the same entry.
2026-11-11 13:43:28 -08:00
Sameh Khamis 21fdc6a332 The renderer contract names what a renderer does, by role
ROLES sorts every member of PORTS into one of six roles: the Earth (streaming
and building the globe from map sources), scene contents, camera and input,
world queries, the look, and the host and frame loop. The ports follow the
API's shape; the roles say what the engine behind them does, and that the app
keeps the data while the renderer owns everything from a source spec or a
draw set down to the pixels. roleOf resolves a member to its role, the most
specific entry winning. No member changes; a test keeps every member in
exactly one role and every entry naming a real member.
2026-11-11 13:36:06 -08:00
Sameh Khamis 1f307e0735 Keyless terrain reaches the renderer as quantized-mesh terrain
The contract's TerrainSpec gains quantizedMesh terrain: Cesium's tile
format in the folder at its url, heights above the ellipsoid. Without an
ion key the globe-port map engine asks for Re:Earth's keyless terrain as
it, where it asked for the ellipsoid, so the renderer
draws the same ground; without the terrain capability keeps the
ellipsoid. Cesium's globe port draws it through CesiumTerrainProvider with
the keyless terrain's retry policy.
2026-11-11 09:20:33 -08:00
Sameh Khamis c57e535275 Merge origin/main: street-level links, embed terrain waits, Swedish, and host-supplied weather frames on the renderer's ports
A weather frame source's regional tiles reach the renderer through the
imagery layer's fetchTile, drawn and handed over as PNG bytes, a null tile
one shared transparent tile; the camera-owner watch listens on the
renderer's canvas.
2026-11-11 09:02:11 -08:00
Sameh Khamis db37617fa6 A transit vehicle back in view is turned for the camera as it is now
Its last turn was kept when it came back into view, so a vehicle that
left the view while the camera moved, and came back after the pass for
the camera's new pose, kept the turn from the old pose until the camera
moved again. Coming back into view now clears its last turn.
2026-11-11 08:38:58 -08:00
Sameh Khamis 37d44c3364 A transit vehicle coming into view is turned along its course at once
The rotation pass reprojected courses only when the camera moved, a poll
marked a course, or a vehicle was moving. A vehicle that entered the view
or was shown on a later visibility sweep (its ground height arriving
after its poll) kept the icon pointing up until one of those happened,
under a camera that held still. The visibility sweep now marks the
rotations for the next pass when it changes what is in view or shown.
2026-11-11 08:16:27 -08:00
Sameh Khamis 6fc1aaff02 A wreck is selected only by a tap exactly on it
The shipwrecks layer reads the click's top hit, as it read the scene's
exact pick before, not the touch contact search's wider hit: a tap that
misses everything near a wreck selects nothing, and a tap near another
layer's contact closes an open wreck card.
2026-11-11 08:09:54 -08:00
Sameh Khamis 46c98796de News country badges are painted at the scene's pixel ratio
A badge's count image is sized by the renderer's own resolution scale
(its quality port's pixelRatio, 1 while that is browser recommended), as
the other icon sets are, not by the device pixel ratio.
2026-11-11 08:07:36 -08:00
Sameh Khamis 3143d106ce Coasting fleet icons stay above the ground, as the CPU coast keeps them
Past its fix a coasting aircraft or military icon is never drawn lower
than COAST_FLOOR_LIFT_M over the ground the layer's floor cache knows,
as floorCoastedPosition keeps the tracked one. The renderer cannot read
that ground, so the planner reads it along the coast arc and plans the
coast in pieces where the ground rises under it: the arc as it is while
the ground stays clear for the lookahead, one-second pieces of the same
arc lifted and climbing where the ground lifts it, and a lifted hold
once the coast is over. Unknown ground is read again on the next plan;
a coast from above any terrain is never read.
2026-11-11 08:07:36 -08:00
Sameh Khamis fa2e8e8551 The sky background is exported: the star catalogue, the Milky Way's faces and the star vertex builder from gods-eye-view/sky 2026-11-10 23:29:40 -08:00
Sameh Khamis bc786f8c55 fix(news): Conflicts reports of the same time come in a fixed order
GDELT exports are read in parallel, so two reports with the same time
arrived in whichever order their exports finished, and the feed test that
pages through them failed now and then. Same-time reports now order by
most mentions, then by id.
2026-11-10 22:40:15 -08:00
Sameh Khamis cd44d5c4d8 The occlusion probe survives a restored context, a depth reader that throws, and queries that never answer
A source's contextGeneration tells the probe the same context was lost and
restored; it then makes its GPU objects again instead of drawing with dead
ones. A depth reader that throws turns the test off for a while instead of
throwing out of add(). Batches whose control point never answers count as
failed ones, so a query path that never answers stands down and is rebuilt
on the retry.
2026-11-10 22:03:36 -08:00
Sameh Khamis aa5c0fb5e3 docs(changelog): weather frame source (#1665) 2026-11-10 21:54:27 -08:00
Sameh Khamis e18353f769 feat(weather): a host can supply decoded frames to the weather layers
A weather feed may also be a frame source. With an optional
getFrameImage({ product, time, size, bbox, signal }) the layers take
whole-extent images, detail windows and the global mosaic from it; with an
optional getFrameTile({ product, time, z, x, y, size, signal }) regional
tiles and their prefetch come from it, null being a transparent tile. Pixels
may be an ImageBitmap, ImageData, canvas or VideoFrame of exactly the
requested size; the layer draws them once and closes them. Cancellation
reaches the source, and a feed without these methods reads the image and
tile routes as before.
2026-11-10 21:54:08 -08:00
Sameh Khamis 730dff53dd Occlusion test without Cesium: the depth probe moves to render/occlusion and reads depth textures too
The GPU probe behind query.occlusionTest no longer depends on Cesium: a
renderer hands it the frame's depth through readSource (a DepthSource), and
createDepthOcclusionTest builds the query port's test from it. Besides depth
packed into RGBA8, as Cesium keeps it for picking, it reads a depth texture
(encoding 'depth', on the GPU only), and log depth with no near plane decodes
too. Cesium's sceneOcclusionProbe.js keeps only its scene
reader. Exported as gods-eye-view/render/occlusion.
2026-11-10 21:48:04 -08:00
Sameh Khamis b226fa820a test(news): briefing stories share one published time, so their order never depends on a clock tick 2026-11-10 21:19:33 -08:00
Sameh Khamis 619c19ea67 Application extras come from the renderer plugin; framing, occlusion and panel drawing are contract ports
A renderer plugin may supply applicationHooks(renderer) for what only its
renderer has (map engine, own credits, stale commands, QA handles). What every
renderer should do moves onto the contract: controls.keepEarthFramed (behind
the keepEarthFramed capability), query.occlusionTest (behind occlusionTest),
and panel drawing, which keepPanelRendering now does through resize and
frame.renderNow through the contract. renderNow throws when the frame fails to draw.

The Cesium port installs its zoom-out guard through keepEarthFramed (a setView
no longer cancels its turn) and answers occlusionTest with the scene's probe;
the stub answers it with a horizon test.
2026-11-10 21:17:56 -08:00
Sameh Khamis a755f63638 Merge origin/main: shipwrecks, news, transit fronts, signal-lost trails and uncredited photos on the renderer's ports
Upstream's layers and changes are carried onto the ports, with no Cesium
outside src/render and no reach into the viewer:

- Shipwrecks draw as one icon set, clicked through the input dispatcher.
- News draws through draw sets, the camera port and the input dispatcher;
  its beacons pulse each frame through the frame port.
- The scene occlusion probe moves into src/render/cesium and reaches
  detection through a new application hook, createOcclusionProbe; its
  private Cesium reads go through internals.js.
- Flight and military trails, the stale and SIGNAL LOST cue, coasting and
  following the world clock run on the draw and frame ports. GPU icons
  follow the scene clock while the world clock is followed, and fade when
  stale. A report that holds is not planned again every tick.
- Vessels are keyed by their record id.

The stub boot now enables military, shipwrecks and news as well.
2026-11-10 20:03:28 -08:00
Sameh Khamis df8728d0ad A failed fallback is not tried again, and focus stays in the credits list as it redraws 2026-11-10 18:57:47 -08:00
Sameh Khamis e440f3dddb A stack kept after a failed recovery still falls back on tile failures 2026-11-10 18:54:10 -08:00
Sameh Khamis 6a6967d1ad Place the credits line where Cesium's is, and draw a logo in place of its text
- Every placement of Cesium's credit display (above the command dock, the
  Minimal HUD's corner, clean view and recording, the phone tab bar and an
  open sheet) has the same rule for the application's line; a test keeps
  each stylesheet's pairs together.
- A credit's logo is drawn in place of its text, which names it (the
  image's alt), as Cesium shows logo credits; the contract's Credit says
  so. Links open with noopener and noreferrer; a list that empties while
  focus is in it hands focus back to the line.
- A stack that stays after any failed switch (a tileset or imagery that
  fails to load, or a photoreal base that fails to come back) still falls
  back on its tile failures: the controller binds its listener again for
  that switch where it handles the failure.
2026-11-10 18:48:26 -08:00
Sameh Khamis 241c8dde64 Write a line that moves by as many points into the points it draws
An undraped line in the polyline collection that moved was given a new
array of Cartesians, one new object a point. One that moves by as many
points, not geodesic, now has its new positions written into the points
its polyline draws, which the polyline then takes again: the range ring's
fronts, stepping out every interval, make no new points.
2026-11-10 18:29:56 -08:00
Sameh Khamis 9743993f8e Measure a pose's heading, pitch and roll in one east-north-up frame
Cesium's camera measures each of heading, pitch and roll by moving the
camera into the eye's east-north-up frame and back, recomputing its
matrices twice each time. In 3D the pose now reads that frame once, takes
the eye's direction and up into it as Cesium's inverse transformation
does, and puts them through Cesium's own formulas: the same heading, pitch
and roll to the last bit or so, and the camera is left as it was. Other
modes still ask Cesium. The camera's matrices are copied straight into
their arrays.
2026-11-10 18:29:56 -08:00
Sameh Khamis a896d886a2 Tell a frame that owes the credits the last one owed without listing them
The credits port compared every drawn frame's Cesium credits with the last
frame's by listing them: a sorted copy of the frame's credits, a set and a
string of ids, after every frame. It now first compares what that list is
made from, value for value (the logo, the static credits and the frame's
own, each with its count and placement, and which are the page's), and lists
them only when one of those changed. Most frames owe what the last owed.
2026-11-10 18:29:56 -08:00
Sameh Khamis 16c7034c28 Show the renderer's credits in the application's own line
- On a renderer whose plugin does not show its credits in a display of
  its own (the ownCreditDisplay hook; Cesium's does), the application
  shows what the credits port lists at the bottom left (#gev-credits):
  inline credits on the line, the rest, the layers' data credits among
  them, in the Data attribution list it opens. The button and list are
  keyboard operable; Escape closes the list and returns focus. Text is set
  as text; links and logos keep only safe schemes.
- The panel, Cockpit and overlay layouts keep clear of it as of Cesium's.
- The stub boot check fails when the credits line is not shown or its list
  is empty; it keeps its report when the run stops early, counts only the
  dev server's providers and other origins as feeds, and a failed default
  renderer load is retried without dropping a newer one.
2026-11-10 18:29:47 -08:00
Sameh Khamis 691cb0cd79 A stack kept after a failed photoreal switch still falls back on tile failures
- When showing the photoreal base fails and the stack before it stays,
  its tile-failure listener is bound again for the switch that kept it,
  so Esri's OSM fallback still runs.
- The Cockpit test of a ride handed to another aircraft checks that the
  follow's change adopted it (the Cockpit took the camera).
2026-11-10 18:29:47 -08:00
Sameh Khamis 5826420a27 chore(changelog): name the contacts fragment for #1662 2026-11-10 18:17:52 -08:00
Sameh Khamis cbbf55cacd feat(vessels): key vessels by their source's stable id, and share a selected vessel
AIS Vessels are keyed by the id their live source gives, with the MMSI as an
attribute: an MMSI can be shared, spoofed or reused, so two vessels with one
MMSI are now two vessels. Looking a vessel up or selecting it by MMSI still
finds it.

A share link made while a vessel is selected opens that vessel. A UUID vessel
id travels as 16 bytes in a new thing field (13). A shared thing that is not
reporting now says so in a sentence per kind, with its id (ICAO, NORAD, MMSI
or vessel UUID) on a second line.
2026-11-10 18:12:53 -08:00
Sameh Khamis 57ff81f723 feat(live): flights, military and vessels follow the world clock when their source declares a timeline
A live source may now declare a timeline: it can answer a snapshot at a
given time (source.timeline = { coverage(), stepMs, subscribe? }, read by
readSnapshotTimeline). While such a layer is on it follows the world clock
and registers the coverage. At the live edge it polls exactly as before;
away from it the layer asks for getSnapshot({ ...query, atMs }) at the step
at or before the clock time and shows that snapshot instead of polling.

src/time/snapshotTimeline.js owns the following: a seek, time going
backwards or leaving live replaces every contact with the snapshot at the
new time (play waits on it, for at most 8 s); playing on keeps one
snapshot ahead and gates play on it, applying those snapshots as polls so
contacts move smoothly; outside coverage the layer is empty; back at live
it is cleared and polls at once. One load at a time, and a load the
source drops for a newer one is not a failure.

While following, aircraft are drawn at the clock time with no render
delay, records and absences are judged at the clock, track requests carry
atMs, and vessels move between fixes along the great circle. The world
clock counts jumps (seeks and returns to live) in getState().

A source with no timeline never follows the clock, and every layer stays
live, unchanged.
2026-11-10 18:12:53 -08:00
Sameh Khamis 874f83ba48 fix(voice): messages worded before reaching the status also follow a language change (#1661)
The radio and push-to-talk helpers shared by both voice providers now pass
English catalog text, and the OpenAI controller words its detail when shown,
like the Gemini session. A token failure without a server message carries
its status as sourceParams, so it is worded again with the number. The docs
say sourceDetail is the message as given, catalog text when it is the app's
own.
2026-11-10 18:11:07 -08:00
Sameh Khamis 1fbe546531 Follow through the camera port in the remaining tests
- The tests that faked a follow by setting the viewer's tracked entity,
  or by raising its change event, follow through the camera port
  (followEntity, or a port with follow and followChanged), and check
  followedOf: camera handoffs, globe rotation, tilt, ground guard,
  vessels, ALPR, CCTV, Contacts, radio, orientation, share links and
  follow offsets, the tracked readout and the shell's camera listeners.
- The fake Cesium camera port delivers followChanged from the port itself.
- A ride handed to another aircraft is adopted by the follow's change, as
  the application does, not by the test calling the adoption.
- The unbound-factory record lists the scene, the map defaults, share
  restoration and the World Packet as entries whose caller loads the
  factories; the map startup test stubs the default renderer load.
2026-11-10 18:10:14 -08:00
Sameh Khamis 9a13aeab48 A photoreal base that fails to come back keeps the stack before it
- The map source controller waits for a base that loads as it is shown
  (the globe engine's tilesetReady) before it takes the stack before it
  down: one that fails throws there, so that stack and its imagery stay
  and the error is reported, as from any failed switch. The Cesium map
  engine has no tilesetReady, so its switches are unchanged.
- A failed default renderer load is tried again by the next call, and
  the standalone page's early load does not report a failure nobody
  awaited yet.
- The adapter ratchet's on-demand import rule refuses a default or an
  empty destructuring.
- The stub boot check fails a layer whose manager answers false rather
  than throwing, or that is not on (or off) afterwards; a field drawn
  counts as drawn; the dev server is closed when the browser cannot
  start.
2026-11-10 18:10:07 -08:00
Sameh Khamis 44dd6d48a8 Changelog fragment for #1661 2026-11-10 18:05:04 -08:00
Sameh Khamis b1c5de0ed1 fix(voice): Gemini voice messages follow a language change
The Gemini session translated each status and error message once, when it
happened, so after a language change the voice control kept showing it in
the old language. The state event now also carries the English catalog text
as sourceDetail, and the control words it when shown. The local server's
known token errors stay catalog text until then instead of being translated
on arrival.
2026-11-10 18:04:52 -08:00
Sameh Khamis 8a4867b1b7 Boot the whole application on the stub renderer, headless, in CI
- dev/stub-app/main.js starts the standalone application on the stub
  renderer with only the contract's required members (?capabilities=all
  gives it every capability) and steps its frames.
- npm run qa:stub-boot serves the application's own page with that entry,
  and fails when any Cesium module or asset is requested (the stylesheet
  the build's Cesium plugin links into every page is reported), on a page
  or console error, or when a data layer fails to turn on or off. A feed's
  failed response and the dev server client's own errors are reported;
  --strict also fails a layer that drew nothing.
- The browser CI job runs it.
- RENDERER-CONTRACT.md and CURRENT-STATE.md describe the application on
  the stub and the boot check.
2026-11-10 17:46:15 -08:00
Sameh Khamis ae4fbb5053 Load the default renderer as the page starts, and follow through the camera port in tests
- The standalone page starts loading the default renderer as it starts
  (loadDefaultRenderer), so Cesium arrives beside the page's own setup,
  not after it; the scene takes a plugin or a promise of one.
- Where a follow target's layer has no display position yet, the followed
  position is the target's own position at the frame port's scene time.
- The globe engine's photoreal base that fails to come back is off again
  and the globe shown; a later switch tries again. The draped-imagery host
  asks the map engine whether the globe is shown where the renderer cannot
  say. The scene resizes the renderer with its container.
- Cockpit and voice tests follow through the camera port (followEntity),
  not by setting the viewer's tracked entity; the fake frame port has a
  scene time.
2026-11-10 17:44:29 -08:00
Sameh Khamis 6daf63d90c Start the application through the contract, not on the Cesium viewer
The application scene takes a renderer plugin and no longer refuses one
without a Cesium viewer. It loads the default (Cesium) plugin only when it
is given none, so a page on the stub never loads Cesium.

- Every layer and tool is handed the application's own scene object
  (createSceneHost): the container and isDestroyed(), bound to the
  renderer, the same on Cesium and the stub.
- What only Cesium needs at startup is done in its plugin's create: the
  free-look height limit, and keyboard access to its credits' expand link
  (creditKeyboard.js moves into the adapter).
- What a plugin may hand the application beside the contract goes through
  provideApplicationHooks, each hook optional: Cesium's map engine, stale
  command trimming, inline panel rendering, viewerDrawsEntity, the zoom-out
  guard, and the viewer QA scripts read from window.__godsEyeView.
- The map stacks, and the photoreal base the scene loads, switch through
  the renderer's own map engine (mapEngineFor), else its globe port
  (globeEngine.js). The Cesium engine takes the scene object and changes
  the viewer behind it.
2026-11-10 17:18:48 -08:00
Sameh Khamis a72d4c3b1f Follow, drape and read the camera through the ports, not the viewer
- What the camera follows is the camera port's target only: no layer
  tracks an entity of its own any more, so followed.js stops reading and
  writing viewer.trackedEntity and the viewer's clock.
- Draped imagery's host is the globe port's imagery while the globe is
  shown (isGlobeVisible, or no shown base tileset where a renderer cannot
  say), else the shown base tileset; weather uses the same resolver.
- The World Packet reads the eye from the camera port's pose, and vessels
  ask again for the view on the camera port's moveEnd.
- The stub's canvas takes event listeners, and in a page is a real canvas
  filling the container it is given; createStubRendererPlugin makes it a
  renderer plugin.

The viewer access record is now empty.
2026-11-10 17:18:10 -08:00
Sameh Khamis ebbe006924 Reach the canvas through canvasOf, not the viewer
Every file that read the renderer's canvas as rendererOf(viewer)?.canvas
falling back to viewer.canvas, and the share restoration's gesture
listeners on viewer.canvas, now ask canvasOf(viewer). The 20 canvas
reach-throughs leave the viewer access record.
2026-11-10 17:18:10 -08:00
Sameh Khamis fdbff75e1e Format the keyless Gemini voice tests (#1660) 2026-11-10 17:10:45 -08:00
Sameh Khamis 0118e17ea6 Changelog fragment for #1660 2026-11-10 17:07:01 -08:00
Sameh Khamis b89f81b729 fix(voice): keyless Gemini voice drops the microphone hint
The Gemini token route now answers a missing key with code API_KEY_MISSING,
the session carries it to the error state as missingKey, and the voice
control hides "Check microphone permission" for that error, as it already
does for OpenAI. The OpenAI controller sends the same flag, so the shared
control and the controller agree whichever updates last.
2026-11-10 17:06:50 -08:00
Sameh Khamis 73735b080a Write the range ring's band a word a pixel and place fronts without angles
The band is copied out of its radius table as whole 32-bit pixels where
the image's bytes line up with words, a byte at a time where they do
not. Each front's positions come from the unit vector on the sphere
straight to the ellipsoid, without going through longitude and latitude
and back; they move by nanometres.
2026-11-10 16:26:11 -08:00
Sameh Khamis d2627b466a Paint the range ring's band and fronts without redoing per-step constants
Each pulse step painted the band with a square root per pixel and built
each front's per-bearing constants anew. The band now keeps which entry
of its radius table each pixel reads while the subject stays put, so a
step only fills the table and copies it out; the fronts keep their
bearings' constants for the centre they were made for and come out the
same bits.
2026-11-10 16:26:11 -08:00
Sameh Khamis f86b8954f6 fix(voice): a missing-key error keeps its wording and hides the microphone hint after a language change (#1599)
The voice error was matched against the translated key message to decide
whether to show the microphone hint, so switching language brought the hint
back and left the message in the old language. The error now carries a
missing-key flag into the status, which words the message at render time.
A controller test covers the language switch, and CURRENT-STATE.md documents
the keyless voice response.
2026-11-10 16:11:30 -08:00
Sameh Khamis 100369f9af Merge remote-tracking branch 'origin/main' into feat/viewport-context-decision-upstream 2026-11-10 15:44:17 -08:00
Sameh Khamis 9234c1b3d2 fix(voice): drop viewport decision codes the caller can never log, name the crop decision eligible (#835)
The decision no longer reports not-entity-context or channel-closed, which
its only caller rules out first, nor pointer-scale-not-useful, which the
crop path already checks and logs. A closed channel returns before any
record, as on main. The crop decision is pointer-crop-eligible, since the
crop checks after it decide whether the pointer is on ground, and a sender
called on a closed channel logs channel-lost.
2026-11-10 15:44:17 -08:00
Sameh Khamis 85f42f6cd8 Changelog fragment for #1659 2026-11-10 15:28:44 -08:00
Sameh Khamis 076d264982 Hide street vehicles behind low walls and trees seen from above
In a dense downtown view from about 400 m up, the occlusion margin of
max(3 m, 2% of the range) came to 14 to 20 m, so a wall, awning, tree or
lower facade standing 10 to 20 m in front of a street was read as the
road itself: the vehicle's dot was hidden by the scene, but its bracket and
callout were still drawn. Checked against scene.pickPosition in one such
view, 18 of 470 vehicles in frame fell in that band.

The margin now depends on how steeply the camera looks down on the
contact. A point on the line of sight s metres in front of a vehicle
stands s * sin(elevation) above it, so a surface there hides the vehicle
once that rise passes 2 m. The margin stays at least 3 m and at most 2%
of the range, so grazing and street-level views are unchanged. In the
same views no vehicle with the drawn surface within 3 m in front of it
(its own road) is newly hidden.

From the review of the first change:

- A contact back in view after longer than a retest interval is held back
  and retested like a new one, instead of being drawn from an answer
  given before it left the view. It gets a fresh record, so a test still
  in flight from before cannot end the hold-back either.
- The hold-back for a contact's first answer stretches with the retest
  pace when a crowded view slows it.
- A batch whose control point failed no longer counts as a first answer.
- An unknown log-depth flag reads as "no depth" rather than as standard
  depth, which would have put every surface in front of every contact.
- A shader that fails to build leaves no shader behind and is not built
  again on the same context.
2026-11-10 15:08:26 -08:00
Sameh Khamis 630e1b1998 Hide street-vehicle brackets and labels behind buildings and terrain
The detection overlay only hid a contact behind the Earth's curve, so a
street vehicle behind or under a building, a 3D tile or a hill still had
its bracket and "VEH-nnnn" callout painted over that geometry, while its
own dot was depth-tested and correctly hidden.

A contact a layer marks `depthTested: true` (only Street Traffic does) is
now tested against the depth the scene drew and left out of the overlay
while a drawn surface stands in front of it by more than max(3 m, 2% of
its range). Other layers are untouched: their markers are drawn over the
scene on purpose.

The test runs on the GPU and never waits for it. Each tested contact is
one point drawn inside an occlusion query; the vertex shader looks up the
frame's packed pick depth at the contact's pixel, decodes it and drops the
point when the surface is nearer than the contact's threshold. Query
results are collected on later frames. Reading depth back was measured
and rejected: `scene.pickPosition` per contact costs 0.2 to 1.4 ms each,
and Chromium answers `getBufferSubData` with a round trip to its GPU
process even behind a signalled sync object (1.5 ms on a quiet machine,
15 to 25 ms on a busy one).

- Contacts are retested every 100 to 200 ms, spread across frames, at
  most 256 a frame; with more in view the pace stretches so none starves.
- Hiding is immediate. A hidden contact returns 600 ms after its last
  "hidden" answer, so one on a silhouette edge does not blink, and a
  contact new to the view is held back until its first answer (400 ms at
  most), so orbiting does not flash brackets behind buildings.
- A callout whose contact goes behind something is dropped at once, not
  carried to the next solve and not faded out on the facade.
- These times run on painted frames, so a hidden tab does not expire them.
- A control point in every batch must draw; if it does not, the batch is
  ignored and after three the probe stands down for ten seconds. With no
  pick depth (2D, Columbus view, depth picking off) nothing is hidden.
  A WebGL 1 context reads depth back synchronously about 8 times a second.

The renderer internals this depends on are read in one function,
`readSceneDepthSource`, with the engine version they were checked against.
2026-11-10 15:08:26 -08:00
Sameh Khamis 0a0645e28e Answer an unmoved camera's pose from the last read
Cesium measures heading, pitch and roll by moving the camera into the
eye's east-north-up frame and back, twice each, and a frame reads the
pose many times over (the range ring's rim check reads it every frame).
The Cesium camera port keys the last pose on everything it is read
from: eye, axes, transform, frustum and mode, and answers from it while
they hold, with objects of the caller's own.
2026-11-10 14:50:57 -08:00
Sameh Khamis 6c49ffe825 Time the arrival reveal from the frame that shows the row again
The reveal probe hides a contact's row, waits for frames that draw it
hidden, and shows it again. Those hidden frames are the probe's setup:
they now restart the reveal's clock and deadline and are reported as
hiddenMs. The row stays hidden for two drawn frames, past the frame that
follows the settle frame, so the reveal is timed on an ordinary frame
instead of on whether that frame was pipelined.
2026-11-10 14:50:48 -08:00
Sameh Khamis f1b843aaa1 docs(changelog): uncredited Planespotters photos are shown 2026-11-10 14:12:58 -08:00
Sameh Khamis 259bc1a024 feat(flights): show a Planespotters photo even when it names no photographer
A photo whose answer gave no photographer was dropped as no photo. It is
now shown, still linked to its Planespotters page, with no credit line.
2026-11-10 14:12:42 -08:00
Sameh Khamis 2992232fcc fix(shipwrecks): tidy after merging main: the retired-token test reuses the retired token, natural Hebrew, voice comment beside its entry
- layerStateTokenLedger.test: the retired-token reuse case now offers the
  retired token (02) to the newcomer, not News's 00.
- he.json: the catalog's singular imperative, {count} first in the plural,
  Wikidata read as one source, and smoother legend and info text.
- layerManifest: News after Shipwrecks, so the prompt-budget comment stays
  next to the entries it explains.
- CURRENT-STATE: Prettier-formatted (table column, blank line before a heading).
2026-11-10 14:07:07 -08:00
Sameh Khamis 8ff22f1a12 Merge main into feat/shipwrecks
Main added the News layer at the same places: both layers are kept in the
layer names, panel order (News stays last of Events), standalone sources,
voice manifest, credits, DATA_SOURCES and the CURRENT-STATE table. News took
share-link token 00 first, so Shipwrecks moves to 01 (ledger, registry,
CURRENT-STATE and the token tests). The catalog now has 40 layers and the
share-link registry 38. Shipwreck strings are added to the new Hebrew
catalog; the other catalogs keep both sides' strings.
2026-11-10 14:03:39 -08:00
Sameh Khamis f9b7a77140 test(shipwrecks): the page deadline subtracts the newest available source's reported age from the limit 2026-11-10 13:42:08 -08:00
Sameh Khamis 41641cd91a fix(shipwrecks): the page clears shown wrecks as a whole, once even the newest source is too old
Removing one source's wrecks on the page split merged records: a wreck both
sources list is one Wikidata record carrying EMODnet facts, so expiring
Wikidata dropped wrecks EMODnet still had, and expiring EMODnet kept its
facts. The page now keeps every shown wreck, marked stale, until the newest
source passes the limit, then clears them all. Adds a source test for the
reported ages and limit.
2026-11-10 13:40:40 -08:00
Sameh Khamis 7704de5075 fix(shipwrecks): the page expires each source's wrecks by its own clock, from the age the proxy reports
The page compared the proxy's fetchedAt with its own clock, so a skewed
browser clock cleared or kept wrecks wrongly; a snapshot without a timestamp
never expired; and one old source cleared the other's fresh wrecks. The proxy
now reports each source's age on its own clock and its seven-day limit; the
page turns them into per-source deadlines when the snapshot arrives (seven
days from arrival when no age is given) and, on a failed refresh, removes only
the sources past theirs. A refused short refresh is logged.
2026-11-10 13:38:31 -08:00
Sameh Khamis 6e4dd6299e docs(shipwrecks): refresh timing and the personal-text filter as they now work, rewrapped
CURRENT-STATE said each source is asked at most once a day; a failed source
is retried after 15 minutes. It now also covers refused short refreshes and
the page clearing expired wrecks, and its two shipwreck paragraphs are
rewrapped. The card's comment no longer says the records carry no names.
2026-11-10 13:36:18 -08:00
Sameh Khamis c885825f2b fix(shipwrecks): rebuild unless the snapshot has a version string; a failed page refresh marks the wrecks stale and clears them after seven days
- A source without a version (undefined, not null) compared as unchanged, so
  an injected source's new snapshots were never drawn.
- When the page could not refresh (the proxy answers 502 once both sources
  are past seven days), it kept showing the old wrecks as fresh. They are now
  marked stale, and removed once older than the proxy's own seven-day limit.
2026-11-10 13:36:18 -08:00
Sameh Khamis 66fba3da47 fix(shipwrecks): a source refresh with less than half of its last good wrecks is refused until the old set expires
A 200 answer that was valid but cut short (30 Wikidata wrecks instead of
about 1,450) replaced the last good set for a day. It now counts as a failed
refresh: the old records are served as stale and the source is retried after
15 minutes; once the old set is past seven days, the new one is taken.
2026-11-10 13:36:18 -08:00
Sameh Khamis 0c159186f9 fix(shipwrecks): small row and query fixes: era counts in one pass, pickers list only years with a wreck, no Portuguese default
- The legend counted each era twice, scanning every record eight times per
  row refresh; it now counts once.
- Each year picker listed every year from the oldest dated wreck (well over
  a thousand entries); it lists the years that have a wreck, plus the chosen
  ends.
- Labels fell back to Portuguese and links to Portuguese Wikipedia while the
  app ships 11 locales: labels now fall back through the app's languages
  after English, and a wreck with no English article links its Wikidata
  item, which lists the article in every language.
2026-11-10 13:29:25 -08:00
Sameh Khamis 38cf1e2be5 test(shipwrecks): an upstream body over its size cap counts as a failed source and is cancelled at the cap 2026-11-10 13:28:10 -08:00
Sameh Khamis 6c4c5dd041 docs(shipwrecks): say the personal-text filter is a keyword filter, not a guarantee that no name is shown
DATA_SOURCES and CURRENT-STATE said text naming people is dropped. The filter
drops text with a title or role word (Mr, captain, owner, crew, reported by);
a bare name with none of them still passes. The docs and the code comment
now say so.
2026-11-10 13:27:59 -08:00
Sameh Khamis dd731a5da9 docs(shipwrecks): describe the layer on its own, not by a layer that is not on main
Air accidents (#1584) is not merged, so comments, the changelog fragment and
CURRENT-STATE no longer explain the shipwrecks markers, card and picker by
it; the row-range test fixture is the shipwrecks row. CURRENT-STATE now says
the markers are one billboard collection and the period is stored swapped.
2026-11-10 13:27:26 -08:00
Sameh Khamis 32e5768954 fix(shipwrecks): take the shipwreck modules out of the GhostMaps package lists
They were listed as owned by the ghostmaps and ghostmaps-source packages,
which they are not part of; ghostmaps-source is meant to stay free of
rendering code, and shipwrecks/index.js imports Cesium. The app groups that
own every layer keep them.
2026-11-10 13:26:23 -08:00
Sameh Khamis 0ac06dad2d fix(shipwrecks): a reversed period is stored in the order the picker shows it, so changing one end keeps the other
A period set as 1950 to 1900 (a link or the voice tool) showed as 1900–1950
but stayed reversed, so changing "From" to 1920 gave 1920 to 1900, shown as
1900–1920: the end the reader did not touch moved.
2026-11-10 13:25:25 -08:00