A particle is a function of its age, not a thing that is stepped (#73)

The asset type `particles` is placeable and carries a graph at the same time —
`behavior` was the blueprint. Because a continuous emitter gives birth to particle n
at time n/rate, the whole field is a function of the clock rather than of the frames:
no ring-buffer bookkeeping, exact time jumps, reproducibility as a measurable property.

compile.ts follows compileShader's frame but emits JS closures into a Float64Array
instead of GLSL, and without eval; a node with two consumers is evaluated once.
Drawing is one Pixi ParticleContainer per source, so one draw call.

Collision, wind and braking in flight are out for good — that is the price of the
formula model, not an omission.

The tab count goes from nine to ten, which is exactly the case #84 was built for one
day earlier: at 1280 px the row no longer holds every tab, so guard 14b now asks for
hidden.length > 0 instead of === 0.

src/editor/debugHook.ts

@@ -3,6 +3,7 @@ import { resolveObjects } from '../core/model/instance';
 import { findObjectHolder } from '../core/model/Project';
 import type { FrameRect } from '../core/model/texture';
 import { activeDrag, Button, ui, Widget } from '../ui';
+import { particleLibrary } from '../viewport/ParticleLibrary';
 import { shaderLibrary } from '../viewport/ShaderLibrary';
 import { textureLibrary } from '../viewport/TextureLibrary';
 import type { CentreTab, Editor } from './Editor';
@@ -280,6 +281,26 @@ export function installDebugHook(app: Application, state: EditorState, editor: E
       center: () => centreOf(editor.stateMachineEditor.canvas),
       snapping: () => editor.stateMachineEditor.canvas.snapEnabled,
     },
+    particles: {
+      current: () => editor.particlesEditor.currentAssetId,
+      pickerAt: () => centreOf(editor.particlesEditor.picker),
+      info: () => editor.particlesEditor.shownInfo,
+      nodeAt: (nodeId: string) => editor.particlesEditor.canvas.nodeGlobal(nodeId),
+      nodeLabel: (nodeId: string) => editor.particlesEditor.canvas.nodeLabel(nodeId),
+      nodeRect: (nodeId: string) => editor.particlesEditor.canvas.nodeRect(nodeId),
+      nodeProblem: (nodeId: string) => editor.particlesEditor.canvas.nodeProblem(nodeId),
+      canvasRect: () => editor.particlesEditor.canvas.canvasRect(),
+      emptySpot: () => editor.particlesEditor.canvas.emptySpotGlobal(),
+      center: () => centreOf(editor.particlesEditor.canvas),
+      /** The strip below the graph: how many particles it draws and which second it stands at. */
+      preview: () => ({
+        count: editor.particlesEditor.preview.count,
+        time: Math.round(editor.particlesEditor.preview.time * 100) / 100,
+        holding: editor.particlesEditor.preview.holding,
+      }),
+      /** Jumps the preview to a second – exact, because a particle is a function of its age. */
+      hold: (at: number | null) => editor.particlesEditor.preview.hold(at),
+    },
     shader: {
       current: () => editor.shaderEditor.currentAssetId,
       pickerAt: () => centreOf(editor.shaderEditor.picker),
@@ -425,6 +446,17 @@ export function installDebugHook(app: Application, state: EditorState, editor: E
     },
     /** Holds the shader clock at `at` seconds, so a Time shader's pixels can be measured; null releases it. */
     shaderTime: (at: number | null) => shaderLibrary.freezeTime(at),
+    /** The same for particle time, kept apart so one can be held without the other. */
+    particleTime: (at: number | null) => particleLibrary.freezeTime(at),
+    particleCompiles: () => particleLibrary.compiles,
+    /** Every source's clock back to zero on the current (usually frozen) second. */
+    particlesRestart: () => {
+      viewport.restartParticles(particleLibrary.now());
+      gameView.restartParticles(particleLibrary.now());
+    },
+    /** What a source is drawing in the scene tab, or in the game view while playing. */
+    particlesOf: (objectId: string, where: 'scene' | 'game' = 'scene', limit = 8) =>
+      (where === 'game' ? gameView : viewport).particleInfo(objectId, limit),
     /** Graphs compiled so far; a moved node must not add one (#65). */
     shaderCompiles: () => shaderLibrary.compiles,
     /** Which views redraw every tick because a Time shader is on screen. */