clamp01(x: number) → number

Maths the whole slice shares

lerp(a: number, b: number, k: number) → number

ramp(x: number, a: number, b: number) → number

0 below a, 1 above b, smooth in between.

spike(t: number, at: number, rise: number, fall: number) → number

1 at the peak, falling to 0 by `fall` seconds after it, 0 before it.

mix3(a: { number }, b: { number }, k: number) → void

scale3(a: { number }, k: number) → void

rng(seed: number) → void

A deterministic stream. Seeded by an integer, never by time, so the layout a build scatters is the same layout on every rebuild and in every take.

tex(name: string) → string

Assets A texture this slice ships, by leaf name: "puff", "glow", "soot", "grain", "ring".

node(name: string, parent: any, pos: { number }?) → any

Entities Find-or-spawn a named child under `parent`. Always temporary: a slice's runtime spawns must not land in the scene as pending entity edits, because the commit gate is world-wide and would refuse every other agent's push too.

light(name: string, parent: any, opts: { [string]: any }) → any

A point light this slice owns. `intensity` is written every tick, so the component is fetched once and cached on the returned record.

tint(rec: any, rgb: { number }) → void

A Light's colour lives on three channels; the composite `color` is an alias the component accepts at `add` time and refuses on the sealed proxy after it. Every per-frame colour change goes through here.

decal(name: string, parent: any, opts: { [string]: any }) → any

emitter(key: string, spec: { [string]: any }) → any

Emitters Create an emitter under `key`, or return the one already made. The spec is forced onto the film's own clock: never `autoUpdate`, because the film advances by a fixed step per rendered frame and an emitter on the scheduler's delta would drift off it within a second.

get(key: string) → any

origin(sys: any, v: { number }) → void

`particles.create` takes `origin` / `direction` as a vec3 table; the setters of the same names take three loose numbers and store whatever they are handed without checking. Passing the table the create spec wanted writes it into `originX`, and the emitter then raises inside its own bounds maths on every later frame, blaming a line in the particle engine. Every move in this slice goes through these two so that cannot happen here.

aim(sys: any, v: { number }) → void

pump(key: string, channel: string, origin: { number }, direction: { number }?, perSecond: number, dt: number) → void

burst(key: string, origin: { number }, direction: { number }?, count: number) → void

A one-off burst from a named place.

clearCarry( ) → void

update(dt: number) → void

Step every emitter by one film frame. Called once, from the slice's tick.

clearParticles( ) → void

Empty every emitter. Called when the film rewinds, so a take starts with no smoke left over from the last one.

destroyAll( ) → void

Release everything. Called when the slice rebuilds from scratch.

count( ) → number

report( ) → void

What every emitter is producing right now, as one line per emitter. The read that answers "is this actually on screen" rather than "did the call return".