- readsthis repo's live issues and PRs
- becomesactivity + recency → mass; references bind items
- writes
--w--field-attention - you seeactive work reads heavy; referenced items move together; the cycle fills like a vessel
No canvas is drawn here — the field is invisible; these variables are its only output. Without it you would build: a priority field, a linked-issues query, and a sprint board.
Data honesty
- Data source
- Real GitHub API data — this repo's (zachshallbetter/fundamental-engine) open issues and pull requests, public repository data.
- Snapshot
- Committed snapshot in src/data/examples/, stamped snapshotAt on refresh via scripts/snapshot-examples.mjs — the build never fetches, so it is deterministic.
- Live refresh
- Upgrades to live in the browser: a polite poll (wireLiveChip) that skips hidden tabs and retires after failures. The committed snapshot is the SSR baseline and the no-JS truth.
- Not claimed
- The field reads activity and recency as mass and references as binding. It does not prioritize the work or assert what should ship next — it makes the repo's own signals legible.
Fundamental · invisible fields · backlog
Work has weight.
This one is the repo measuring itself: the 64 most recent work items from Fundamental's own repository — the issues and pull requests that built the engine rendering this page. A tracker flattens them into identical rows; here each item is a body, and its mass is a blend of activity (discussion) and freshness (how recently it was touched). Heavier items read darker, heavier, more anchored.
Work also binds: when an item references another, hovering it threads back to what it builds on — across lanes. The board has two: In flight and Shipped, and the shipping cycle has visible capacity — everything closed or merged in the 14 days before the snapshot accretes into the bar that heads the Shipped lane. Switch the weighting and watch each lane re-settle; toggle the field off and it collapses to a plain tracker. And the cards drag — pick one up and triage the board by hand. It's a local sandbox: the arrangement saves in your browser, and GitHub is never written.
size = activity, comment-leaning — the items people argue about carry the mass · color = kind — teal pull requests, blue issues
- Aa size = the weighting signal
- color = kind (teal PR · blue issue)
- hover → threads to the items it references
- the cycle bar is a sink — shipped work accretes into it
- the soft glow = live density — the hidden
engine writes
--dto every card each frame; it gathers under your cursor and ebbs back
drag to triage — local only, GitHub unchanged
Draggable work item. Press Space or Enter to lift the card, then arrow keys to move it: up and down within the lane, left and right across lanes. Press Space or Enter again to drop, or Escape to cancel. Rearranging is a local triage sandbox — GitHub is not modified.
In flight 32
- #1270 issue track: compare real integrations and extract recurring engine needs
- #1319 PR chore(site): weekly example-snapshot refresh
- #1255 issue investigate: define which field results must survive presentation changes
- #1293 issue audit(research): independently verify 2026 forced Navier–Stokes proof and novelty construction by construction
- #1254 issue docs(research): distinguish demonstrated behavior from validated product benefit
- #1266 issue site(case-study): Zach Shallbetter portfolio — document the real integration
- #1273 issue plan: define 1.0 acceptance through supported consumer workflows
- #1272 issue investigate: define multi-field isolation and resource coordination
- #1271 issue investigate: map consumer usage to capability maintenance priorities
- #1297 issue [EPIC] FE × FCI parity: executable semantics, trustworthy evidence, and comparative demonstrations
- #1318 issue [P1][FCI-PROT] Map FE apparatus to ICP/EQP/SES/SSS/RDP/RPP without duplicating protocol authority
- #1317 issue [P0][FCI-OPS] Read-only FE/FCI bootstrap adoption assessment and pinned protocol manifest
- #1262 issue docs: reconcile supported product boundaries across interface and headless use
- #1298 issue [EPIC] FE × FCI semantic parity: canonical crosswalk, kernel safety and conformance
- #1299 issue [EPIC] FE × FCI demonstrations and evidence: headless, multi-projection, human evaluation
- #1316 issue [P1][FCI-D5] Benchmark FE-specific incremental value with ablations, strong simple baselines and independence controls
- #1315 issue [P1][FCI-D4] Calibrate Observatory as a research instrument and test interpretive failure modes
- #1314 issue [P1][FCI-D3] Prepare FE projection/signaling laboratory for FCI CIS-EX-008 without inventing user results
- #1313 issue [P1][FCI-D2] Demonstrate a headless multi-participant workflow with policy and event-log baseline
- #1312 issue [P1][FCI-D1] Demonstrate one evidence-review world across visual, nonvisual and agent projections
- #1311 issue [P0][FCI-D0] Establish demonstration protocols, baselines, falsifiers and cost scorecard
- #1310 issue [P1][FCI-C10] Add reproducible FE–FCI research gate with precise versions, CI coverage and claims manifest
- #1309 issue [P1][FCI-C9] Separate FE snapshot narration, deterministic replay, trace verification and causal inference
- #1308 issue [P1][FCI-C8] Build a dual-implementation adversarial conformance corpus for FE TypeScript and FCI C11
- #1307 issue [P1][FCI-C7] Make FCI's seven comparison-admissibility gates executable as an honest decision profile
- #1306 issue [P1][FCI-C6] Implement typed measurement/evidence boundary and unresolved empirical obligations
- #1305 issue [P1][FCI-C5] Map FE World/Dynamics to FCI formal models and explicit observation limits
- #1304 issue [P1][FCI-C4] Typed projection invariance and cross-channel semantic preservation contracts
- #1303 issue [P0][FCI-C3] Adversarially test interaction episodes, recurrence, timescale and identity
- #1302 issue [P0][FCI-C2] Reconcile opportunity sets, authority scope and recovery semantics with FCI
- #1301 issue [P0][FCI-C1] Fail closed on unknown world invariant kinds and incompatible readings
- #1300 issue [P0][FCI-C0] Build source-pinned 16-family FE ↔ FCI concept, version and evidence crosswalk
Shipped 32
- #1221 PR merged feat(core): NavGrid — obstacle-aware navigation and goal flow-fields (#439)
- #1210 PR merged feat(core,dom,elements): pulse() — the transient per-body flare, on its own channel (#567)
- #1212 PR merged feat(core): pointer dynamics + throw — the cursor participates, and a release carries (#666)
- #1208 PR closed fix(core): the simulation clock starts at the first frame, not at construction (#1207)
- #1216 PR merged feat(core,elements): render 'lic' — the force field as texture, not as arrows (#671)
- #1175 PR closed fix(kotlin): warp pairing — the resolution step the port never had, so `warp` stops being dead code
- #1180 PR merged docs(refactor): Phase 6 — the five-section spine, ten retirements with redirects, and a status-honesty sweep (#1001)
- #1179 PR merged fix(core,swift): a reading is not matter — the overlay stops dying with the underlay render mode (Field Surfaces S0)
- #1217 PR merged feat(core,elements): tab order as a field current (#943)
- #1211 PR merged perf(core,dom): observer-driven measurement — stop polling a page that is not moving (#689)
- #1209 PR merged demo: a dedicated mass field — first-class inertia, made visible (#1142)
- #1214 PR merged feat(dom,vanilla): contained fields stop when their box scrolls out of view (#672 lane S2)
- #1215 PR merged refactor(core,elements,site): one overlay vocabulary, checked in both directions (#672 lane R0)
- #1213 PR merged fix(core): the lazy overlay surface — one DPR ceiling, and no canvas it can never paint (#672 lane S0)
- #1219 PR merged refactor(core,elements,ci): one render vocabulary, checked in both directions (#1218)
- #1237 PR closed chore(site): weekly example-snapshot refresh
- #1276 PR merged fix(core): recover #1208 clock-origin fix on current main
- #671 issue closed Flow-field LIC render mode
- #1294 PR closed chore(site): weekly example-snapshot refresh
- #1288 PR closed chore(site): weekly example-snapshot refresh
- #672 issue closed Field Surfaces: `inline` placement
- #1287 PR merged fix(kotlin): recover #1175 pairing with public-radius regression tests
- #1207 issue closed bug(core): `reaction: true` is not deterministic — six identical seeded runs drift monotonically
- #1275 PR merged docs: correct recovery ancestry guidance and reconcile open work
- #1001 issue closed docs-refactor Phase 6: IA refinement — redirects, status sweep, retire/merge stale pages
- #439 issue closed core: obstacle-aware navigation + goal flow-fields (FieldKit gap #2)
- #567 issue closed feat(core): per-body pulse/flare primitive + a completion-flare recipe
- #666 issue closed Pointer dynamics + throw (core/pointer.ts)
- #943 issue closed Tab-order current: directional flow along the focus/tab sequence (deferred from #665)
- #689 issue closed Observer-driven measurement
- #1142 issue closed demo: a dedicated mass field for /demo (momentum A visual)
- #1218 issue closed One render vocabulary: RENDER_MODE_LIST, checked in both directions
How it's built
Every work item is an ordinary <li> with a few data attributes — the
GitHub API response, flattened into markup. Fundamental runs an invisible field over the
list and the type carries the measurement: activity as weight, kind as color, references
as hover threads. No canvas, no chart library. Two live channels ride on top: the page's
hidden engine writes --d (local particle density) to every
data-hot card each frame, and the scoped pattern's attention lane writes an
eased --field-attention — CSS turns both into a felt glow and lift, and both
go quiet when the field is off. Each card also declares its updatedAt as
data-field-at, so the pipeline's recency lane is grounded in the data's own
timestamp — --field-recency is freshness(updatedAt, now), decaying
against the real clock rather than inferred from interaction. The drag is hand-rolled pointer events — no library, no
HTML5 drag-and-drop — and it's a local triage sandbox: the arrangement persists to
localStorage, and GitHub is never written.
1 — each work item is a field body
<li
id="wi-294"
data-body="attract"
data-strength="1.42"
data-feedback
data-hot
data-act="0.91" data-rec="0.99"
data-field-at="2026-06-09T22:41:00Z"
data-field-halflife="86400000"
data-refs="wi-282 wi-269"
style="--w: 0.94; --cat: #2dd4bf;"
>
<!-- #number · kind · title · author -->
</li>
<!-- data-rec is the snapshot's freshness —
freshness(updatedAt, snapshot, 24h), the
@fundamental-engine/core temporal kernel. data-field-at
declares the same updatedAt as WORLD TIME, so
the platform's recency lane is grounded in the
data: --field-recency = freshness(at, now). --> data-act/data-rec— the normalized signals the lenses re-blend (data-recis thefreshness()kernel overupdatedAt, half-life 24h)data-field-at— the declared world timestamp; the platform grounds its recency lane in it (--field-recency)data-refs— the items this one references (the hover threads)data-strength— gravitational mass from the blended weightdata-hot— opts into the live density gather: hover and--dclimbs toward 1
2 — the cycle bar's two honest channels
/* the cycle bar is a real sink body that also
declares itself as its own measurement:
<div id="wl-cycle" data-body="sink" data-absorb
data-max="8" data-feedback data-hot
data-field-visual-for="#wl-cycle"
data-field-visual-role="measurement">
channel 1 — data arithmetic: the FILL is
shipped ÷ capacity from closedAt dates. */
width: 100%; /* 32/20 this cycle */
/* channel 2 — the live engine: --load (0..1) as
particles accrete into the sink, blended with
--live (the engine's local density, --d). */
box-shadow: 0 0
calc((var(--load, 0) + var(--live) * 0.5) * 22px)
color-mix(in srgb, var(--accent)
calc(var(--load, 0) * 40% + var(--live) * 20%),
transparent);
Two channels, kept honest: the fill is static math over the snapshot's
closedAt dates; the glow is the live engine — --load from a
real sink body, blended with the local density --d. The bar
also names itself as a measurement visual
(data-field-visual-for), so its provenance is declared, not implied.
3 — CSS reads the weight and the live channels
.wl-title {
font-variation-settings:
'wght' calc(380 + var(--w) * 360);
}
.wl-item {
/* --d: the engine's live local density,
written every frame; it gathers toward 1
when a data-hot card is hovered/focused.
--field-attention: the scoped pattern's
eased attention lane (hover/focus +
viewport-center proximity + visibility). */
--live: var(--d, 0);
box-shadow: 0 0 calc(var(--live) * 16px) -6px
color-mix(in srgb, var(--cat)
calc(var(--live) * 55%), transparent);
background: color-mix(in srgb, var(--text)
calc(1.5% + var(--w) * 4% + var(--live) * 4%
+ var(--field-attention, 0) * 4%),
transparent);
}
Switching the lens re-blends --w from data-act and
data-rec, then FLIP re-sorts each lane so the reflow is felt, not cut —
on the current arrangement, so re-sorting a hand-triaged lane re-orders it;
the lens always wins the order. The glow and lift read --d and
--field-attention — both written by the running field, both zeroed when
it's off.
4 — the drag is pointer events, by hand
// hand-rolled pointer drag — no library, no HTML5 DnD.
card.addEventListener("pointerdown", (e) => {
if (e.target.closest("a")) return; // links still click
pend(e); // arms only after 6px of travel
});
function lift(card, e) { // past the threshold
card.setPointerCapture(e.pointerId);
placeholderFor(card); // a gap holds the origin slot
card.classList.add("wl-drag"); // fixed, grabbing,
// touch-action: none
// pick a card up and the field re-measures it in
// flight: data-active marks the body engaged, so the
// attention metric writes a rising --field-attention.
card.setAttribute("data-active", "");
}
function track(e) { // every pointermove
card.style.transform = `translate(${e.clientX - x0}px,
${e.clientY - y0}px) scale(1.03)`;
placeSlotIndicator(e); // the slim line between cards
edgeScroll(e.clientY); // ±60px, proportional speed
}
function drop() { // pointerup — Esc/pointercancel aborts
insertAtSlot(card); // displaced cards FLIP-settle
card.removeAttribute("data-active");
recountLanes(); // counts + cycle bar go "(local)"
save(); // localStorage only — GitHub is never written
}
Pick a card up and the field re-measures it in flight: data-active marks
the dragged body as engaged, so the attention lane's --field-attention
rises while you hold it. Drops FLIP-settle the displaced cards, recount both lanes,
and re-run the cycle arithmetic — marked (local) when it diverges from the
snapshot. Keyboard works too: Space lifts, arrows move, Escape cancels.