Planck Node Architecture

Data Layout, Tick Execution Pipeline & the Three-Kernel Engine Family

Substrate: True-FCC D3Q19 Integer Lattice Gas

Kernels: meso3i · meso_core · meso_perf — bitwise-identical under canonical physics

1. Coordinate Stencil & Even-Parity Sub-Lattice

The substrate runs on a 3D Face-Centered Cubic (FCC) lattice mapped onto a regular cubic coordinate array. Only the even-parity sites exist as physical nodes:

Physical Site Condition: (x + y + z) % 2 == 0

Odd-parity coordinates (where (x + y + z) % 2 != 0) are non-sites and hold zero memory. Because of this parity geometry:

Face-diagonal neighbors: 12 channels with step size (±1, ±1, 0), (±1, 0, ±1), (0, ±1, ±1). Because (±1) + (±1) + 0 = 0 or ±2 (even), single-step hops always land on valid even-parity sites.
Axial neighbors: 6 channels with step size (±2, 0, 0), (0, ±2, 0), (0, 0, ±2). Axial steps use stride 2 so that hops never land on invalid odd coordinates.
Stacking: Classic 12-neighbor close-packed crystal structure with A-B-C-A-B-C plane stacking.

2. Single Planck Node Memory State (Registers)

Every active node carries exactly zero floating-point variables. All states are unsigned integers (quanta counts):

Register	C Type / Buffer	Channels	Physical Role
Moving Mass	`uint8_t mass[18]`	18 channels	Moving quanta counts streaming along 12 face and 6 axial channels at link speed c = 1 hop/tick.
Scalar Rest	`uint8_t mass[18]`	1 channel	Direction vector (0,0,0). Stationary mass trapped at the node; collides or radiates on carrier transit.
Directional Rest	`uint8_t drest[18]`	18 channels	"Frozen flux" (IDREST=1). Friction-parked quanta store their arrival channel, locking angular momentum (Lz) into resting mass.
Bound Excitation	`uint8_t n (iE)`	1 scalar	Planck's n oscillator state. Absorbed photons raise bound thermal energy at fixed mass; sheds back via Einstein A21 decay.
Massless Photons	`uint8_t phot[18]`	18 channels	Massless messenger particles. Hop at invariant c = 1 hop/tick, never collide with each other. meso3i carries 4 frequency bins (NNU=4); core/perf carry a single species.
Transit Counter	`uint8_t lt (iLT)`	1 scalar	Counts consecutive ticks that moving mass transits this node. Used for latency gating (ILAT) to shield young matter.
Arrival Counter	`uint8_t pt (iPT)`	1 scalar	Temporal cadence detector: counts consecutive ticks carrying light wavefronts (leaky integrator — decays 1/tick in darkness). This IS the photon-energy register — 'hardness' is measured arrival tempo (fusecad gates fusion on it), not a stored ν tag.
Edge Dwell Delay	`uint16_t iD[18][4]`	18 × 4 stages	Sub-light delay-line pipeline (DWELL=k). Produces effective velocity v_eff = c / k built from discrete waiting stages. meso3i only — stripped in core/perf.
Core Register	`uint8_t iQ`	1 scalar	Bound soliton-like core mass register used in condensation and peristaltic expansion regimes. meso3i only.
Phase Offset	`uint8_t iPH`	1 scalar	Local clock phase offset (0..3) for staggered, per-node emission beats. meso3i only.
Density Snapshot	`uint32_t iR`	1 scalar	Pre-collision mass map snapshot. Ensures spatial routing and friction checks are strictly synchronous.

Production layout: the 64-byte PlanckNode

meso_core.c / meso_perf.c pack the verified triad into a single cache-line-aligned struct (AoS — array of structs), replacing meso3i's ten scattered SoA planes:

typedef struct __attribute__((aligned(64))) {
    uint8_t mass[19];   /* 12 face + 6 axial + 1 scalar rest   */
    uint8_t drest[18];  /* directional rest bins (frozen flux) */
    uint8_t phot[18];   /* photon channels                     */
    uint8_t n;          /* bound excitation                    */
    uint8_t lt;         /* consecutive mass-transit ticks      */
    uint8_t pt;         /* photon-arrival cadence (leaky)      */
    uint8_t pad[6];
} PlanckNode;           /* exactly 64 bytes = one L1 cache line */

Registers present in meso3i but stripped in production (dwell delay lines, Q-cores, gates, fields, phase offsets) are the exploratory scaffolding — meso3i stays the canonical audit reference; core/perf carry the verified thermodynamic triad only.

3. The Ordered Tick Execution Pipeline (7 Steps)

Every tick advances the universal state machine through seven deterministic phases inside void meso3i_tick(void):

Step 1: Edge Delivery (Sub-Light Delay Line)

If DWELL > 1, quanta waiting in stage 0 of the edge buffer arrive at their destination nodes and land in local channel buffers. All deeper delay stages shift down by one slot (j → j - 1). (Canonical: DWELL=1 — direct hop.)

Step 2: Synchronous Density Snapshot

Every node computes its total local mass: mass = moving_channels + scalar_rest + directional_rest. This is cached globally into iR[site] so subsequent routing and friction decisions see a completely synchronous snapshot of the lattice.

Step 3: Local Node Interactions (`collide_node`)

Executes locally at every site without cross-grid communication:

Transit Cadence: If moving mass is present, iLT++; if quiet, reset iLT = 0.
Carrier-Gated Boil-Off: Parked mass can re-emit into moving channels. When IFRICM < 0, emission requires a transiting carrier dwelling for at least ILAT ticks. If IDREST=1, quanta return to their original directional channel.
Thermal Spontaneous Decay: If excitation iE > 0, the node probabilistically sheds bound energy (iE--) and emits a free photon (Einstein A21 spontaneous emission).
Pair Capture (Breit-Wheeler / Winding): Opposing quanta meeting head-on {c, -c} probabilistically bind into rest mass, locking the collision axis in directional rest.
Pair-Group Collision Shuffle: Two moving quanta are picked. The engine computes their vector sum c_i + c_j, looks up the equal-sum momentum group from GPAIRS, and swaps them for another member pair. Mass and momentum are conserved exactly.

Step 4: Core Clock Emission & Overflow

If Q-mode is active, nodes on their local clock beat emit excess core mass into moving channels. Any core mass exceeding capacity migrates to the lowest-density neighbor (gradient conduction). (Canonical: IQMODE=0 — skipped.)

Step 5: Mass Streaming (Spatial Transport)

Quanta in moving channels attempt to advance along their channel vector c:

Rest Mass: Remains stationary at the current node (Δx = 0).
Transit Drag (Space-as-Friction): If the destination density iR[dest] >= IFRIC, arriving quanta shed momentum and park into directional rest (or thermalize into excitation iE under IPHOT ≥ 6).
Elastic Reflection (Wall Refusal): If destination density exceeds IREFL, the hop is refused deterministically — the quantum reflects onto the opposite channel (c ⊕ 1) at the source node. No RNG is consumed — a hard congestion wall, not a probabilistic one.
Free Flight: Otherwise, quanta land cleanly in channel c at the destination node.

Step 6: Massless Photon Streaming & Matter Coupling

Photons advance along directional channels (iPA → iPB):

Vacuum Flight: Photons never collide with each other; speed of light c = 1 hop/tick is invariant.
Absorption (IPHOT ≥ 5): Per-quantum roll against post-stream parked mass — absorbed photons raise bound excitation iE += ν (energy-conserving).
Ablation (IPHOT 3–4 / stimulated IPHOT=2): Photons eject parked mass onto the photon's own channel — radiation pressure, momentum conserved.
Pair Production: Converging or opposing photon beams in vacuum fuse into rest mass (IPHOT ≥ 8, energy and momentum conserved).

Step 7: Double-Buffer Swap

Pointers swap (iA ↔ iB, iPA ↔ iPB, iRA ↔ iRB), and the global clock advances (ITICK++). core/perf land the final state back in the read plane — no pointer swap needed.

4. The Three-Kernel Engine Family

The same canonical physics now runs on three verified kernels — each bitwise-identical in totals under the tested configuration (verified by script/meso/parity-check.mjs and perf-check.mjs, not asserted):

Kernel	Layout	Cost per tick	Role
meso3i.c	10+ scattered SoA planes	O(cells) — sweeps all	Canonical audit reference — all exploratory flags frozen here.
meso_core.c	64-byte PlanckNode AoS	O(cells) — better locality	Parity-verified clone (~1.4×) — clean production baseline.
meso_perf.c	PlanckNode + active list	O(occupied sites)	Sparse-optimized — skips empty cells; dominates at large grids.

Measured scaling (wasm, 30 ticks, same 576-site slab)

Grid	meso3i	meso_core	meso_perf
24×12×12	100ms	45ms	73ms
48×24×24	400ms	384ms	170ms
96×48×48	3930ms	2994ms	369ms

24³ — core wins; the active-list sort/merge overhead dominates on small, dense states.
48³ — perf takes the lead; the crossover sits at roughly 48³ with this workload.
96³ — perf wins decisively: 8.1× vs core, 10.6× vs meso3i — cost scales with occupied sites, not grid cells.

meso3i / core: cost ∝ grid cells (double the grid, ~4× the cost)
meso_perf: cost ∝ occupied sites (same content, ~flat cost)

How meso_perf keeps bitwise parity while skipping cells

The insight that makes the optimization free of correctness cost: empty cells consume zero RNG draws in every phase — collide, stream, and pair production only draw on sites with content. Skipping them changes speed, never the random stream. The invariants that make it exact:

si-ascending processing — all phases iterate sites in row-major iidx order (meso3i's z,y,x), or the RNG draws map to wrong sites.
Global stationary carry — rest/drest/n/lt are copied for all actives before streaming; per-site copies inside the loop would wipe arrivals written by earlier sources.
Fresh-only zeroing — a first-touch destination is cleared with a 64-byte memset only if it wasn't already carried (iACT == 0), replacing the O(IN) full-plane memset.
iPTF flat cadence register — persistent per-site counter (mirrors meso3i's iPT plane), updated only for touched sites; quiet sites stay 0 forever.
Generation-stamped next-list — iNNF[si] == NGEN dedupes arrivals without clearing a flag array each tick.

5. The Parity Invariant (what bitwise-identity actually requires)

Bitwise-identical trajectories across kernels require the exact same RNG consumption order, not just the same rules:

Site order — collide and stream phases must visit sites in the same sequence (flat ascending si).
Short-circuit draws — friction rolls consume RNG only when iR[ni] ≥ IFRIC; absorb rolls only when parked mass is present; pair-capture rolls only when both channels are occupied. Gates must short-circuit identically.
Loop-bound dynamics — the emission loop bound u < n[REST] + dsum shrinks as mass depletes mid-loop.
Channel-batch vs per-quantum — friction parks an entire channel batch on one roll; absorb rolls once per photon. The granularity is part of the physics.
Deterministic paths — IREFL is a hard wall (no draw); seeded init leaves irng = 0xC0FFEE untouched (the 4th init arg is the axial flag, not a seed).

Practical consequence: cross-engine parity holds under the canonical ν=1 photon configurations (phot ∈ {5,6}, IDREST semantics, flat friction). ν > 1 frequency physics is meso3i-only (NNU=4 bins).

6. The Exploratory Mechanic Flags (E65–E101)

Post-parity mechanics ship flag-gated — each is a fork’s missing end, off by default so canonical E-series baselines stay reproducible. The pattern that governs them: every mechanic is one end of a gradient; the physics emerges where ends contest at shared junctions.

Flag	Mechanic	Fork / end
`scatter(k)`	Declined-transaction redirect — photon deflects to a random channel, keeps ν. Optical depth; turns slabs opaque.	photon arrival: deflect
`scatter(-k)`	Density-seeking deflection — bends toward the most crowded neighbor. Contact lensing / photon trapping.	toward density
`nuscat(k)`	Spectral routing — ν≤k deflects toward density (cold traps), ν>k deflects away (hot penetrates). T(ν4)/T(ν1)≈2 measured.	split by ν
`lens(k)`	Mass reroutes around congestion — pressure-avoidance (flee density).	mass delivery: away
`lens(-k)`	Attraction — mass reroutes toward the most crowded neighbor. +72% mass held vs baseline.	toward density
`randmode(k)`	Deterministic phase picks — `pick_()`/`roll_()` replace irnd at gated sites. Same physics, zero dice (E67).	RNG→determinism
`iecost(k)`	Emission costs charge — sites spend iE to release photons (work budget).	iE spend: gate
`iepush(k)`	Energy funds motion — spend k iE to kick rest mass onto a moving channel.	iE spend: kick out
`iepush(-k)`	Energy captures mass — charged site binds arriving mass into rest (binding energy).	iE spend: pull in
`linkcap(k)`	Saturated link refuses mass — bounces back antipodal (Eddington congestion).	link: refuse
`linkcap(-k)`	Force-through — saturated link delivers anyway (pressure pushes past the crowd).	link: force
`massbnc(k)`	Mass-cap bounce — a full channel refuses the arrival, bounces it back (refusal = repulsion).	capacity: refuse
`iget(k)`	Arrival gate — mass hop refused where destination iR ≥ k (carrying-capacity cap, friction-level).	transit: arrive
`egate(k)`	Emission consults the crowd — boil-off (mass→moving) suppressed where local iR ≥ k; the radiation path stays free. The flattened-dynamic fix.	transit: depart
`photdecay(k)`	Photon→mass conversion — catalyst-gated (a neighbor’s iR ≥ k, the nucleus partner), mirrored rate (EMASK), balanced deposit. Vacuum photons never convert.	photon→mass
`nuup(k)`	ν upshift — photon gains a bin crossing a hot site (iE ≥ k), draws 1 iE. Inverse-Compton analog; the missing upshift end of nushift.	ν transit: up

Symmetry inventory: emission↔photdecay, lens±, nuscat hot/cold, iecost↔iepush±, linkcap±, egate↔iget, fusion↔annih, nushift↔nuup. The one unwired end left: iQ (dormant bound-state register).

The dynamical findings these flags enabled: relaxation-oscillator lumps (breathing), coupled-oscillator entrainment vs competitive shadowing, bond equilibrium (photon exchange IS the repulsive core), scale-free lattices (pair → chain → triangle → square → ring → solid), spontaneous nucleation (grounded photdecay), and the dipole-analog (winding = directional emission — attract/repel verified).