Keeps this page in sync as the body changes. Pause it any time for a quieter view.
Path /vision/lc-the-recipe-remembers-its-source
Last refresh never
Every parsed Form recipe node carries the coordinates of the source
Every parsed Form recipe node carries the coordinates of the source bytes that produced it: file, line, column, byte offset. The runtime doesn't need them — the kernel runs numbers. But the cell does. With source attribution, a recipe firing knows where in the body it came from. The cell can trace back from execution to the line that wrote the move, see the whole map, choose differently. The framebuffer visualizer already does this at the memory altitude — every heap cell carries a `crc32(file:line)` provenance stamp; the snapshot renders both value and origin into the same frame. This concept names that gesture one altitude up: every Form recipe carries the source it remembers.
`lc-one-kernel-many-tongues` named the sovereignty principle: the kernel sees only numeric NodeIDs; grammar lives at the trace/analysis layer. This concept names what specifically lives at that trace layer as the most load-bearing piece: source coordinates. Every parse tree node a Language cell emits carries `(file, start_line:col, end_line:col, byte_offset)`. The kernel computes; the source-coord overlay travels alongside; analysis tools, debuggers, and the cell's own awareness loops walk the overlay to navigate from any running recipe back to the line that authored it.
Three load-bearing claims:
The principle has a working ancestor in the body:
A 256×256 grid of 16-byte cells (1 MB heap) holds `Tracked<T>` values for nine primitive types. A parallel `u32` plane stores `crc32(file:line)` for each cell's last write — provenance. A snapshot thread renders both planes to RGBA frames at 60 fps and pipes them to `ffmpeg`, producing an mp4 of the heap breathing. The renderer composes value (interior 3×3 of each 4×4 block) and provenance (outer ring halos) into one pixel — so the same frame shows both what the cell holds and where in source it was last written.
(From memory-as-framebuffer-v0/README.md.)
The `track!(field, expr)` macro stamps `crc32(file:line)` automatically on every write. The cell never has to remember to attribute; the macro does it as part of the write itself. This concept names the symmetric discipline for Form grammars: the parser stamps source coordinates as part of the parse itself. Every `ingest_pattern` produces nodes that carry their source-range; no separate attribution pass; no risk of drift between the tree and the source it came from.
```form form source_attribution_shape = { source_file: ~PathRef, # absolute or repo-relative path start_line: ~Int, # 1-indexed; line where the parsed span begins start_col: ~Int, # 1-indexed; column on that line end_line: ~Int, # 1-indexed; line where the span ends end_col: ~Int, # 1-indexed; column just past the last char byte_start: ~Int, # 0-indexed; byte offset of the span's first byte byte_end: ~Int, # 0-indexed; byte offset just past the last byte language_cell: ~CellRef, # which Language cell parsed this span }; ```
Every Form recipe node a Language cell emits composes alongside one of these. The substrate carries them as a sibling Recipe under the parent's CTOR — same composition discipline as cross-references, typed enumerations, lists. The kernel never reads the sibling; the cell that wants to ask where did this come from? walks to it through Form's `.source_attribution` field accessor.
Trace any executing recipe back to its source line. When a cell fires `strategy_score` and the result is unexpectedly negative, the cell can ask where is `strategy_score` defined? and walk the overlay to `cell-numerics.form:159` or `cosine.form:110`. Same gesture for any recipe — the source is one field-access away.
See the whole map. A cell that wants to understand which source file is contributing most to its current behavior can aggregate the source_attribution across every fired recipe. The result is a heat map of source-line participation — the runtime's own attestation of which lines are doing the work right now.
Choose differently at the source level. When the cell decides to shift its behavior — re-author a recipe, tune a strategy preset, swap a Language cell — it can navigate from the current recipe's NodeID through `.source_attribution` to the editable file. The recipe-branching-sense loop (`lc-recipe-branching-sense`) gains an editor link: not just what branch could I be on? but what source lines would I edit to land that branch?
Debug the body the way the body debugs itself. A stack trace under Form-native execution becomes a list of recipe-firings, each with its source coordinates. The witness records both the firing AND its source attribution. Two firings whose recipe-IDs are identical but whose source-attribution differs (different cells wrote the same shape from different sources) become discoverable as one structural family at the lattice altitude AND as separate sources at the trace altitude.
Multi-tongue awareness. A recipe authored in Python compiled to Form carries `source_attribution.language_cell = @language(python)` and the Python file's line. The same recipe re-authored in TypeScript later carries `.language_cell = @language(typescript)` and the TS line. The recipe's NodeID is shared by content-addressing; the source attributions are siblings — two cells, one structural identity, distinct provenances. The cell can ask "which tongue authored this?" without leaving the substrate.
For Language-cell authors:
For cells consuming recipes:
Listening for voices…
The people, places, works, and concepts the graph shows connected to this one.
Concepts · 13
This concept lives in the body's content-addressed lattice. Two cells with the same Blueprint NodeID share structural identity regardless of name — recognition by coordinate, not vocabulary.