Engram Mind’s Eye · Explainer 5 · Phase 3

The Browser Core

The Python reference decided the claims. Phase 3 puts the same system in the browser: one module, engram_core.js, built on the code the orbital pages and Hyperbolic PolyStep already ship. It reproduces the golden corpus and the reference’s exact traces line for line, and this page checks that live.

Run the parity check here Run a session System map
849/849 parity lines 27/27 behaviour checks 6/6 planted errors caught
Contents
  1. Where this sits
  2. One module on the shared cores
  3. How it is checked
  4. Parity, live
  5. A session in your browser
  6. Using it
  7. Smaller changes
01

Where this sits

The browser core takes the Python reference’s logic and the shared cores’ code, and is what the 2D and 3D pages will run on.

02

One module on the shared cores

engram_core.js is UMD: a global EngramCore in a page, require() in Node. It re-implements nothing that already exists. It loads five modules and adds only the engram layer.

It loadsFromFor
orbital_core.jsscripts/geometric-build (Phase 1)Exact fractions, the Einstein tile, SHA-256 and the Lemma 15 Merkle chain, the gauge, the readout and its lock, the pump
hyperbolic_core.jsHyperbolic PolyStepThe norm-5 tree (generators, children, word quaternion, right division) and the seeded generator
decoder3d.js, twin3d.jsHyperbolic PolyStepThe tree laid out in H³ with exact decoding; the exact quaternion product and qnormExact of the mirror law
fence.jsHyperbolic PolyStepThe 0.7 Claude fence, its ln 2 guard, the distance matrix and the corruption of one distance
ttmpt_core_v1.jsthis folder (verbatim from Owl Academy)engram/1: Mulberry32, the letter grids, XOR crystallization, Hamming distance, chiral key, torsion J

What it adds is a line-by-line twin of the reference’s modules, in the same order of operations, so that every exact value and every float comes out the same:

Python referenceIn engram_core.js
ttmpt.pyBoth tokenizers, biomesh.js’s engram stream, the 128-bit packet chain (PacketChain)
address.pyThe 28-letter address, the chain word and quaternion, unfolding by right division
memory.pyThe triple-quad word with its Form 5 tiles, Merkle chain, locate, rebuild and repair; memory links
clock.pyThe schedule, zero points, the membrane turn, registers with 72 blocks and 10 groups, telescoping, engagement
coupler.py, session.pyCoupler (the mirror law and its control) and Session, a dialogue end to end with outputs()
dialogue.py, recall.pyThe dialogue store and synthetic dialogues; Hamming recall, the parity-keeping variants and the substitutions
watch.pyE7’s fence screen settled by the exact address check, and E8’s guard

The orbital ports in orbital.py have no twin here: in the browser the original, orbital_core.js, is used directly. Neither does stats.py, the bootstrap, which only the claims runner needs.

03

How it is checked

Two files fix what the module must produce, and it is compared with them one case at a time.

TargetLinesWhat a line is
reference/golden/engram_v1.json (claim E1)613Each of the 536 entries computed by Owl Academy’s own page and by biomesh.js (hex, 64-bit seed, chiral key, J, bit count); the two tokenizers on three texts; the engram stream; each of the 69 packets of the golden chain; the final codex parity. The same 613 cases E1 decided in Python
reference/traces/engram.json236The Python reference’s exact values: 12 addresses, the chain word and quaternion and its unfolding; the schedule; all 23 memory words of the golden session (cells, tiles, Merkle root, link); 30 gauges with their readout nodes and lock; a complete register of dialogue 9000 (its packet, block and group products, telescoping, the pumps); the coupler at every zero point; the watch layer on four E7 and five E8 instances; the three guards of E10 on 20 corrupted matrices (added in Phase 7); 40 recall queries

Quaternions and fractions are compared as exact strings, some of them hundreds of digits long; 64-bit words as hex; floats with ===. The traces use only unregistered seeds (dialogue 9000, the watch layer on 9100–9104), so checking them never touches what the claims runner decided.

On top of the parity lines, the module runs the 27 checks of the Python tests on itself with the same seeds: every single-bit flip located and repaired, double alterations refused, the controls of the address, the registers and the coupler breaking what they should, free-run closing every register, the lock exactly when the three distances are equal, the fence’s flags all settled, and recall’s variants and substitutions. One check uses different seeds from its Python twin: the substitutions, which Python draws from E9b’s registered seeds 1000 + i and the browser from 9000 + i.

Does the check catch anything?

Six errors were planted in copies of the two files: one 64-bit seed of the corpus, one packet’s footer, one Merkle root, one group product, the coupler’s final quaternion and one recall hit. The check failed on exactly those six lines and passed the other 823.

node "Pages/Engram Minds Eye/tests/parity-engram.cjs" --quiet
Parity: 849/849 lines match the reference
Behaviour: 27/27 checks of the Python tests hold (about 3.5 s in all)
04

Parity, live

This page loads the module and the two target files and runs every line in your browser. Open a section to read its lines.

Lab · engram_core.js against the reference
Loading…
05

A session in your browser

The same code, on your words. Each token becomes a packet in the chain; the window rides the zero-point clock; a memory word is written at each zero point; the coupler binds the two streams.

Lab · one dialogue, end to end
#TokenFromHeaderBody (seed64)FooterNearest concept
The last memory word
Alter the word to see Lemma 15 locate the cell and the parity rebuild it.
Recall
06

Using it

There is no build step. A page loads six scripts in order; Node needs one require.

<script src="scripts/geometric-build/orbital_core.js"></script>
<script src="Pages/Hyperbolic Oracles/hyperbolic_core.js"></script>
<script src="Pages/Hyperbolic Oracles/decoder3d.js"></script>
<script src="Pages/Hyperbolic Oracles/twin3d.js"></script>
<script src="Pages/Hyperbolic Oracles/fence.js"></script>
<script src="Pages/Engram Minds Eye/ttmpt_core_v1.js"></script>
<script src="Pages/Engram Minds Eye/engram_core.js"></script>

const EC = window.EngramCore;
const run = new EC.Session([['strix', EC.tokenize('I am STRIX')], ['human', EC.tokenize('Show me a geodesic')]], 'carry');
run.chain.packets; // header, seed64, footer, triangulation of every token
run.words; // the memory words written at the zero points, with roots and links
run.registers; // 720-frame registers with block and group products
run.coupler.log; // the binding at every zero point

// Node
const EC = require('./Pages/Engram Minds Eye/engram_core.js');

The pages of Phases 4 and 5 will be built on this, so what they show is what the reference computed.

07

Smaller changes

  • ttmpt_core_v1.js moved from spikes/ to the system’s folder, where the browser core and the pages load it. Its text is unchanged; the spikes and the architecture lab now load it from there, and the four spikes give the same output as before.
  • The traces gained a watch section: four E7 instances and five E8 instances on seeds 9100–9104, so the browser’s fence and guard are checked too. Every other section of the file is unchanged, and the reference’s 41 tests still pass.
  • run_traces.py says which seeds the watch section uses, and why they stay clear of the registered ones.