Product-minded engineer building type-safe tools, runtimes, visual systems, and data products.

TypeScript · Rust · Go · React · WASM · Data Systems

ocev · npm · picea

I like building tools that turn messy real-world workflows into clear, typed, and debuggable systems.

My work usually sits between:

• frontend infrastructure and developer experience
• runtime / compiler / engine experiments
• visual debugging tools
• AI-assisted engineering workflows
• market data and paper-trading systems

I started from product/UI work, but I enjoy pushing ideas all the way down to implementation details: API shape, type inference, runtime boundaries, tests, docs, and local verification loops.

A TypeScript event toolkit for writing cleaner WebSocket, WebRTC, DOM, and media event flows.

ocev started from a practical frontend pain point: DOM event handling is verbose, cleanup is easy to forget, and async event flows often become callback soup.

It provides:

• type-safe SyncEvent
• EventProxy for DOM / Web API event targets
• waitUtil, waitUtilRace, waitUtilAll, waitUtilAny
• async iterator event streams
• ReadableStream support
• debounce / throttle listener options
• automatic event binding and cleanup
• npm package, docs, tests, and CI

import { EventProxy } from "ocev"

const ws = EventProxy.new(new WebSocket(url))

await ws.waitUtilRace([
  { event: "open", timeout: 1000 },
  {
    event: "error",
    mapToError: () => new Error("websocket connect error"),
  },
])

for await (const { event, value } of ws.createEventStream(["message", "close", "error"])) {
  // typed event workflow
}

A work-in-progress 2D physics engine written in Rust.

Current focus:

• World-based core API
• deterministic simulation scenarios
• debug snapshots and query pipeline
• local simulator tooling
• React Canvas workbench for visual inspection

Some active repositories are private because they contain unfinished product experiments, local workflows, or research notes.

A Rust-based Scratch compiler and runtime experiment.

Current scope includes:

• Scratch project parser
• bytecode IR
• VM / runtime
• renderer backends
• CLI tooling
• Android runner / store shell experiments

A paper-only Polymarket account analysis and copy-trading simulator.

Safety boundary:

• no private keys
• no signing
• no real orders
• read-only data ingestion
• paper replay and scoring only

A Rust cross-platform agent runtime experiment with a TypeScript/Vite browser validation shell.

Focus areas:

• Agent core loop
• WASM bridge
• structured events
• tool-call lifecycle
• VirtualFS boundary
• provider bridge and web timeline

Typed APIs over stringly-typed glue
Small abstractions that survive real usage
Debuggable runtime behavior
Clear module boundaries
Docs that help future agents and humans
Tests before broad refactors
Product feel + engineering depth

Languages:    TypeScript, Rust, Go
Frontend:     React, Vue, Next.js, Vite, Canvas
Runtime:      WASM, SDL2, Web APIs, Event Systems
Data:         PostgreSQL, Redis, Drizzle, BullMQ
Tooling:      Jest, Vitest, Cargo, Docker, Just
AI Workflow:  Codex, repo maps, AGENTS.md, verification gates

I have contributed to frontend, Rust, WASM, agent tooling, and embedded-adjacent projects.

Some examples:

• event library design and regression tests
• HTTP client lifecycle fixes in long-running agent gateways
• WASM binding ergonomics
• Rust trait support improvements
• frontend component interaction fixes
• embedded TCP disconnect callback fixes