this.me / Tests

Fire Test

Full kernel validation — phases 0–8, reconstruction proof, secret contracts, and contract suite.
Run: node tests/fire.test.ts

Phases 0–8

Phase 0 — Identity + Secret Scope

Root identity claim (@) is accepted
Secret scope root stays stealth (undefined)
Secret leaf data remains readable by path

Phase 1 — Structural [] Selectors

Bracket selector writes create indexed nodes
Bracket selector reads resolve exact indexed leaves

Phase 2 — [i] Broadcast with '='

One rule is broadcast to all collection members
Each member gets an evaluated contextual result

Phase 3 — Logical Filters

Single and compound filters return only matching nodes
Filter evaluation works on derived fields

Phase 3.1 — Filtered Broadcast

Broadcast assignment runs only on nodes matching filter
Non-matching nodes remain unchanged

Phase 4 — Range + Multi-Select

Range selectors [a..b] slice contiguous subsets
Multi-select selectors [[a,b,c]] slice sparse subsets

Phase 5 — Transform Projection

Read-only projection computes transformed values
Projection output is numeric per selected member

Phase 6 — Contract Integrity

Cross-scope formula (public + secret leaf) computes deterministically
Final invariant equals expected numeric result

Phase 7A — Temporal Rehydration (Replay)

Memory log can be exported from the current runtime
A new empty instance can replay that memory
Replay reconstructs equivalent semantic results

Phase 7B — Atomic Snapshot Rehydration

Snapshot exports full kernel state
A fresh runtime can import snapshot atomically
Imported runtime preserves exact encrypted structures

Phase 8 — Incremental Recompute + Explain

Derivation dependencies tracked from '=' expressions
Changing a referenced leaf triggers targeted recompute
explain(path) exposes expression inputs with public/stealth origin
Stealth inputs masked in explain() while still auditable
Invalid code tokens rejected and remain declarative strings

Reconstruction (32/32)

32/32 Reconstruction Proof 126.27ms

simple string seed produces stable identity
12-word phrase seed produces stable identity
hex string seed produces stable identity
sentence as seed produces stable identity
unicode seed produces stable identity
single character seed produces stable identity
very long seed produces stable identity
256-bit random seed produces stable identity
'luna' and 'luna2' produce different identities
'jose' and 'JOSE' produce different identities
'abc' and 'abc ' (trailing space) produce different identities
ten different seeds all produce distinct identities
anagram seeds produce different identities
reconstruction from seed produces identical identity hash
reconstruction produces same namespace key material
reconstruction works after writing secret scope data
three independent reconstructions all produce same hash
seed does not appear in memory log
seed does not appear in snapshot export
seed not readable through proxy path
seed not enumerable on proxy surface
me[Symbol.for('me.seed')] returns the seed
me[Symbol.for('me.identity')] returns hash and expression
identity hash is a valid hex string
identity hash has fixed 64-hex length
me[Symbol.for('me.expression')] returns null before @ is called
root @ sets active expression and escape plane mirrors it
scoped @ keeps claim behavior without replacing kernel active expression
identity hash is independent of write history
identity hash is independent of creation time
identity hash is independent of process state
web3 analogy — same mnemonic always derives same address

Secret Suites

7/7Secret Material V383.38ms

same input yields the same chain and the same 32-byte material
branch and value diverge for the same secret path
sibling leaves share branch material but diverge at value level
changing the active noise boundary changes derived material
changing a relevant nested secret changes derived material
branch mode rejects the root secret scope
legacy effective secret behavior remains unchanged

13/13Secret Blob V3 — Read92.76ms

v3 branch blob reads through normal secret path
v3 value-level blob reads through normal path
value-level cache does not leak mutable object references
value-level cache invalidates when secret epoch changes
branch write preloads v3 keys cache for immediate cold read
branch cache priming is scoped to the written chunk
branch cache priming invalidates when secret epoch changes
tampered branch blob bypasses primed cache and fails closed
v2 and legacy blobs remain readable
tampered v3 branch blob fails closed
wrong secret for v3 branch blob fails closed
wrong path for v3 value-level blob fails closed
wrong noise for v3 branch blob fails closed

7/7Secret Blob V3 — Write77.86ms

default write now emits v3 branch blobs
default write now emits v3 value-level blobs
forcing v2 still emits v2 branch blobs and remains readable
forcing v2 still emits v2 value-level blobs and remains readable
migrateEncryptedBranchesToV3 migrates v2 chunks and preserves history
migrateEncryptedBranchesToV3 skips already-v3 chunks
tampering after migration still fails closed

Contracts

20/20DSL Contract Tests (Phase 6)181.51ms

boot + basic set/get
constructor bootstrap preserves callable proxy after hydrate
execute dispatch keeps kernel and keyspace routes stable
mutation helpers preserve learn + replay semantics
public memory surfaces redact effectiveSecret and stay replayable
snapshot import accepts both public and legacy memory payloads
phase1 selector [] fixed id
phase2 iterator broadcast [i] with '='
phase3 filter read + phase3.1 logical filters
phase3.1 filtered broadcast for '='
phase4 multi-select and range
phase5 transform projection
runtime escape plane exposes reflective kernel helpers
explicit guest scope does not collapse back to owner scope
explain() masks stealth inputs while keeping public inputs visible
explain() exposes expr plus recompute wave metadata for the selected target
secret branch blobs are non-deterministic across identical writes
tampered v2 secret blobs fail closed
legacy xor secret snapshots still decrypt after v2 hardening
secret caches stay bounded under broad secret traversal

11/11Secret Blob Hardening (4B.0)

legacy secret snapshot still decrypts correctly
v2 secret branch snapshot still decrypts correctly
mixed public+secret snapshot rehydrates without leaking
secret root stays stealth after rehydrate
pointer into secret branch still resolves correctly
tampered branch blob fails closed
tampered value-level encrypted leaf fails closed
wrong secret key fails closed
wrong noise boundary fails closed
blob copied to sibling scope path does not decrypt
replay from public memories preserves secret semantics

Full Summary

Suite	Status	Time
phases	✅ 11/11	152.91ms
reconstruction	✅ 32/32	126.27ms
secret-material-v3	✅ 7/7	83.38ms
secret-blob-v3.read	✅ 13/13	92.76ms
secret-blob-v3.write	✅ 7/7	77.86ms
contracts-summary	✅ 31/31	181.51ms

✅ ALL FIRETEST TASKS PASSED