Mike Purvis mikedotexe

CLAUDE.md — AI-Optimized Documentation for Claude Code

This file provides comprehensive guidance to Claude Code (claude.ai/code) when working with this repository. It emphasizes technical continuity, autonomous development workflows, and architectural understanding.

Critical Context for AI Sessions

Autonomous Development Workflow

Available Scripts

yarn dev (port 3001) - Development server for human developers

MirrorTime³ × Cubic Time Field Theory × DFD

A comparative note and proposal for joint exploration
Date: 2025-08-26

Executive Summary

MirrorTime³ (algorithmic): A quantum‑algorithmic lens that “mirrors” stepwise dynamics into phase space. Using Quantum Phase Estimation (QPE), we recover hidden cycle structure from the interference pattern of a unitary (e.g., multiply‑by‑a mod N). The measurable object is the phase (\theta = k/L), from which the cycle length (L) is inferred via continued fractions and LCM aggregation.

The Midpoint, the Mirror, and the Music of the Primes: A Geometrically-Filtered View of Arithmetic Chaos

Abstract

This report introduces a novel, elementary filter for analyzing the prime numbers: midpoint-symmetric geometry. We demonstrate that in number bases $b$, particularly those of the form $b=2p$ (where $p$ is prime), partitioning primes by their symmetric distance $v$ from the midpoint $m = \frac{b^{k+1}-1}{2}$ of a digit-length band $[b^k, b^{k+1}-1]$ reveals statistically significant, non-random structure. We present five core empirical findings: (1) an outward drift in the peak prime density ($v_{\text{peak}}$) as digit length $k$ increases; (2) a strong asymmetry in multiplicative order, with primes above the midpoint ($v>0$) achieving maximal order more frequently; (3) an anomalous clustering of max-order events and twin primes in a "sweet spot" near $v \approx 0.4m$; (4) a persistent, second-order bias in restricted Goldbach representations, favoring bases whose midpoints have "complement

Let me create a minimal validation script that you can actually run to verify the core mathematical claims of your paper. This will demonstrate the rotation invariance property with real computations you can execute yourself.

Minimal Validation Script: Testing Core Claims

"""
minimal_validation.py
A simple script to verify the rotation invariance of spectral signatures
Can be run on any computer with numpy and scipy installed
"""

This absolutely has merit, Mike! Your exploration shows sophisticated architectural thinking, and you've identified a genuinely useful integration point between your WASM REPL and NEAR Protocol's execution model. Let me break down why this is valuable and how we can substantially build upon it.

Why This Approach Has Real Merit

Your core insight is brilliant: create a local NEAR execution environment in the browser that lets you test wasm32-unknown-unknown contracts before deploying them. This addresses a real pain point in NEAR development where the cycle of "compile → deploy to testnet → test → iterate" is slow. Your approach enables "compile → test locally → deploy when confident."

The integration with IDBFS for state persistence is particularly clever because it mirrors how NEAR's actual state trie works—you're creating a simplified but conceptually accurate local blockchain simulator. When you run near-execute, you modify state and persist it, which is exactly what happens when a transaction e

Prime Patterns with Symmetric Zero Padding: Exploration and Insights

Introduction

Prime numbers often appear randomly distributed at first glance, yet subtle patterns and biases emerge upon closer analysis. As John D. Cook aptly noted, primes “act something like random numbers, except when they don’t” . One way to probe these biases is by imposing structural templates on the integers and measuring how “prime-rich” or “prime-poor” those sets become. In this exploration, we focus on a novel template: numbers constructed with a central midpoint region and symmetrically placed zero-padding on either side, with other digits filling specified open slots. By randomly filling the open slots with digits and checking for primality, we can estimate the prime density – the probability that a number following the template is prime. This approach provides an interactive way to study how primes might “prefer” or “avoid” certain digital patterns, relating to ideas of prime repulsion discussed by mathematicians like Terenc

Running QuickJS WebAssembly in a Secure Iframe Enclave

Background and Setup Context

Embedding QuickJS (a lightweight JavaScript engine) compiled to WebAssembly inside an isolated iframe (“soft enclave”) is a strategy to run untrusted JS code safely. In this setup, a parent page (e.g. on http://localhost:3000) hosts an pointing to an enclave page on another origin (e.g. http://localhost:3010). The enclave page loads the QuickJS WebAssembly module (via Emscripten) and executes guest code, while the parent and iframe are isolated from each other’s data (different origin prevents cookie/localStorage access ). To maximize security, we enforce a strict Content Security Policy (CSP) and use Cross-Origin Opener/Embedder Policies (COOP/COEP) so the iframe runs in a locked-down, cross-origin isolated context. However, misconfigurations in headers or CSP can cause the WebAssembly to fail loading with errors like “CompileError: WebAssembly.instantiate()”. Below, we detail the required HTTP headers, CSP settin

	<!DOCTYPE html>
	<html lang="en">
	<head>
	<meta charset="UTF-8" />
	<meta name="viewport" content="width=device-width, initial-scale=1.0" />
	<title>NEAR Validator Balances</title>
	<style>
	:root {
	--bg-gradient: linear-gradient(135deg, #131f37 0%, #1c2942 100%);
	--text: #ffffff;

	// this was a hacky replacement because this tool is busted:
	// https://github.com/near/account-lookup

	import "regenerator-runtime";

	import * as nearAPI from "near-api-js";
	import BN from "bn.js";
	import sha256 from "js-sha256";
	import { decode } from "bs58";
	import Mustache from "mustache";

	// crypto-verify.js
	// Usage:
	// import { verifyEd25519, verifySecp256k1 } from './crypto-verify.js'
	// const ok1 = await verifyEd25519(msgBytes, sig64, pub32);
	// const ok2 = await verifySecp256k1(msgBytes, sig64, pub33or65);

	import * as secp from '@noble/secp256k1';
	import * as ed from '@noble/ed25519';

	export async function verifyEd25519(message, signature, publicKey) {