Spw Reference Surface
Spw Operator Atlas
A sigil is useful when it changes what a reader knows how to do next.
Each operator is a small contract between text and tools: #>name[register] sets an address, ?<inquiry> opens a probe, and ^{parts.whole} synthesizes an integrated relation. It tells a reader or runtime what kind of structure is present and how it can be inspected.
Operators are semantic actors; braces carry structural facts. The sigil tells you what kind of move is being made: ~[anticipate] holds a potential path, @[viewpoint] situates an observer, and ![commit] commits a consequence. The container tells you what kind of boundary or scope is being entered: {direction} holds a bounded practice, [variant] indexes a selectable lens, and (scene) stages an observable midprocess.
Spw is compact notation for a projection you can rehearse: nouns can hold variants [variant], behaviors {behavior}, and lenses @[lens]; components can expose the same root under different display conditions; and familiar moves can recombine without every page explaining itself from zero. Returning learners can treat the atlas as a lookup table and a grammar practice room at the same time.
Each sigil is a physics anchor. The move you can make and the meaning of the written mark are the same sign, and the brace is the boundary that sign sits on. A still, a filter, or a shot can share the anchor: the mark names the poles and the mix, and the renderer stays behind the handle. On each operator page, the move and the written mark share a sentence, and the physics becomes visible when you stay with it.
Familiar root
The repeated word or sigil is the stable grip. It should remain readable in plain text, markup, and screenshot.
Typed distinction
Brackets, braces, and lenses clarify whether a difference is variant, behavior, scope, or interpretation.
Combinatoric genre
Reusable operators can produce cards, scenes, prompts, runtime handles, and visual motifs from the same semantic family.
Boonhonk can act like a combinatoric genre: a pantry of reusable moves where a familiar ingredient changes meaning through preparation, timing, pairing, and presentation. The grammar should let a reader notice the difference between a variant, a behavior, and a lens without needing a lecture every time. A genre morph is the next move: the same stem under two pressures, not a mash. boonhonk[genre]{combine.discover.reward} boundary geometry {kitchen} ~ (session) Mid is the mush. Name it, or pick a seat.
A sigil stays learnable in plain text, and that same mark is the interactive anchor.
You want to compare what a mark does in interaction with what it means on the page.
Operator literacy, route handles, promptable syntax, and reusable semantics for future public pages.
One reason languages like this matter is that they can train anticipation. A typed statement like ~statement{anticipate.rehearse} can be subvocalized and checked for shape before it runs — the same "speech bubble metaphysical expertise" (l'n'd'r's clay golem magic) that turns operators into inner-speech rehearsal and attentional objects. That subvocalization resonates with cauldron priming (^[gather]), spell casting (*{replay.chain}), and section-handle/resonance-probe refinements so the page echoes back matching operators across contexts. The same anticipation can spill outward into other literacies, including the more bodily ones around nutrition, chemistry, and weekly routine. Cauldron hook + visibility modes let you jump from a collected note to its living source on page and dial how prominently candidates appear while you practice the grammar.
It can also spill back toward math. One structural clue I want to keep public on this site is that integration by parts (^[parts]{handoff.residue}) can be read as a boundary-aware rewrite: the handoff becomes explicit, the residue stays visible, and the remaining work moves elsewhere. That is why the differential lambda calculus bridge belongs near the atlas.
What survives a change of position?
I use these operators as handles for thinking. Turn the square, then reflect it. The arrangement changes; each handle keeps its meaning and destination. Which neighbors stayed neighbors?
- AddressFind a named handle
- QuestionOpen an inquiry
- PossibilityHold an available path
- ActionCommit a move
Four quarter-turns return to the start: R⁴ = I. Two reflections do too: M² = I. Try the two sequences: RM ≠ MR. Here arrows read left to right.
These moves generate the eight symmetries of a square, called D4. Side adjacency survives; orientation and reading order can change. This is a symmetry of positions, not a claim that Spw operators have interchangeable meanings.
Is “metamaterial” a useful way to think about a language?
For my own thinking, a metamaterial is a useful analogy when arrangement changes how something responds. HTML gives a component an address and boundaries. CSS tunes its response to focus, selection and neighboring structure. JavaScript makes a state change explicit. Spw holds the claim I can return to and test.
For navigation, a graph with local response rules is more precise: nodes have addresses, links connect them, and a gesture follows an edge. A rotation can preserve neighbors without preserving an argument. I want the metaphor to help me notice that difference.
Compare component material states · Inspect an expression in the parser · Follow the tooling questions
Same stem, different seats
A word like beans can enter conceptual space as a wrap or as a postfix. The destination may rhyme; the binding does not have to. This page collects practical reasons for the parser to tell those seats apart — it does not decide the grammar for the workbench.
Prefix wrap addresses the noun from outside. Postfix rides the seam after the stem has settled. So <beans># is “enclose, then resonate the closed concept,” while beans.< is “ground the stem, then open a concept edge.” Similar space, different collar.
If a form has no action yet, the parser still has a job: show tokens, AST, or a diagnostic. A graceful no-op here is evidence, not a broken link. Load the whole cluster as one specimen: beans combinatorics in the literal parser.
Comparison as a differential
Two seats of the same stem are not one idea. Place them on a range, keep both handles parseable, and let the joining sigil hold the distinction without collapsing it.
Binding seat binding <beans> ~ beans.< — wrap is a felt enclosure; postfix edge is the inspectable seam after the stem has settled.
Poles are AST handles: change the prefix, the place, or the measure-kind and the sentence still names one axis. Register only changes how loud the placements read. See .spw/conventions/comparison-differentials.spw.
Joins you can challenge
Opening { leans objective. Closing } leans subjective. The crawl is between complete practices. Tight dots inside one brace are one identifier — the parser keeps it whole. Comma holds company; semicolon counts a schedule; ~> holds a path. There is nothing that is cure about laminate about mill.
Cullet, grog, and fiber in one bin. Held together. Parser splits on comma.
One workshop name. Parser keeps it whole. Segments are for navigation, not a list of other names.
Each brace is a workshop practice. Dots walk the gradient between them.
Potential, then an edge. Scrap holds a path that projects without collapsing.
Hold a living term — mill, cullet, scrap — and matching marks on this page should echo. Chips leave for the parser, the register, and the quest. The garden cauldron still writes its own vessel identifier. An or is still a need.
Check a reading with __SPW_SITE__.parser.parse('…') and compare join to kernel.
Operator Philosophy
The atlas is not only an index of tokens. It is a claim about how readers, tools, and future interfaces should generalize what a semantic move means. If you came here from another route, use the repeated tokens as anchors and the surrounding prose as the explanation of why they matter.
An opening brace or frame edge should bias toward enclosure, setup, and what can be shared. It marks where attention gathers.
Square-bracketed structures narrow what is being addressed so a reader or tool can compare, quote, or inspect a smaller region.
Parenthetical forms hold a temporary relation together without claiming a stronger projection or commitment than the text has earned.
A closing brace is residue: what the run did, what you take. Dots crawl from the open bed toward that close. Consolidation, not a dead ornament.
Projection is not a new source of truth. It is the same structure becoming visible in another room: page, panel, prompt, outline, or tool.
The public site should therefore translate plugin-shaped semantics into quieter interactions: enter the scope at the opening edge, inspect inside the body, and let the closing edge bias toward selection, serialization, or projection. Returning readers can keep the same tokens in view while the surrounding explanations get shorter.
Orient
Use the atlas as a field guide
- Return to the software surface#software The operator atlas is one layer inside the broader language design surface.
- Use the operator ring?ring The ring gives a compact orientation map before you go token by token.
- Enter the pretext lab.lab The lab keeps the atlas tied to experiments instead of leaving it as pure taxonomy.
Inspect
Inspect tokens as semantic actors
- Frame operator#> Naming a place is the first step toward shared human and machine navigation.
- Object operator^ Objects show how structured material can stay inspectable inside readable text.
- Probe operator? Inquiry operators are how a reader or tool asks more of the same source.
Commit
Separate action from projection
- Action operator@ Actions are local commitments and should feel different from later manifestations.
- Binding operator= Bindings pin names and categories so subsequent projections can stay faithful.
- Pragma operator! Constraints and forces belong to the local runtime contract before they show up elsewhere.
Project
Follow the block into another room
- Surface operator> This is the explicit projection move: the same structure rendered into another encounter. Web platform projections (see MDN CSS custom properties, Intersection Observer for attention flow) keep Spw faithful to browser substrate.
- Spw alchemistry>flow The alchemistry section shows how attention changes phase as it becomes stream or surface.
- Website publishing register>site The public website is one projection surface where these operator contracts remain visible.
Operators are verbs for readers and tools
An operator should not behave like a cosmetic badge or arbitrary feature switch. It should announce an intent that both a human reader and a machine reader can understand: inquire, refer, bind, commit, project, compare, normalize.
Braces carry topology
The operator says what kind of act is occurring. The brace says what kind of container receives that act. That separation keeps the language extensible: the same semantic move can appear in different substrates without confusing action and boundary.
Generalization should follow intent groups
For menus and public interfaces, it is often better to group operators by reader intent than by raw token list: orient, inspect, commit, compose, and project. That keeps the language teachable without flattening away its semantic distinctions.
Projection is not the same as action
An action commits a local change. A surface projects a structure into another encounter. Keeping those separate matters because authors need to know when they are deciding something and when they are manifesting it for another substrate.
The atlas should stay compatible with the plugin
I mostly meet Spw through the VS Code plugin and local workspace. The website atlas should therefore act as a faithful public guide to the same semantics instead of inventing a prettier but incompatible vocabulary for readers.
Good semantics reduce fake interactivity
If a token implies selection, projection, or scope change, the interface should have a credible action for it. Otherwise the public surface should stay quieter. The language model should sharpen expectations, not disappoint them.
Nearby Context
Surfaces already in contact with the atlas
- Software surface.surface The atlas is the smaller-scale grammar inside the broader readable-source argument.
- Pretext lab.lab Experiments keep the atlas connected to authoring rather than drifting into pure abstraction.
- Authoring seed.seed The seed shows how operator contracts can remain explicit inside one concrete block.
Subsequent Context
Where readers usually go after the thesis
- Operator ring#ring Once the philosophy is clear, readers usually want the compact comparison map.
- Action operator#action Separating local commitment from projection is one of the most important next distinctions.
- Surface operator#surface Projection semantics become more intuitive once the explicit surface contract is read closely.
Projected Context
How these contracts leave the atlas
- Website field guide>site The public site should teach the same semantics in a friendlier medium.
- Spw workbench>plugin The plugin and local workspace are denser projections of the same operator and brace logic.
- Workbench as a project>project What the workbench holds, how long it took, and what using it taught.
- Blog surface>artifact Published fragments are where operator semantics prove they can survive outside a reference atlas.
Voice markers invite readers to try a stance.
Decorating language should not mean adding noise. A good marker gives the reader a small costume for attention: a way to read the sentence as question, artifact, spell, field note, rule, or scene.
# names the room
Use frame markers when a passage needs a place to stand: title, threshold, register, or route. The voice becomes more architectural.
? opens the aperture
Use probe markers when the reader should hold uncertainty instead of receiving a conclusion. The voice becomes curious, provisional, and generous.
~ keeps an echo nearby
Use reference markers for callbacks, memory, sources, and motifs. The voice becomes threaded rather than linear.
^ makes the phrase holdable
Use object markers when a phrase should feel like a card, talisman, specimen, or tool. The voice becomes more material.
@ asks for a move
Use action markers when language should become a ritual, instruction, edit, or invitation. The voice becomes more kinetic.
[] {} tune the costume
Use brackets for variants and braces for behavior: scene[comic]{soften}, note[field]{collect}, question[gentle]{return}.
Starts by naming the habitat, then asks the reader to notice one thing. Useful when the page should teach without sounding like a lecture.
Turns a sentence into a small replayable outcome. Useful when the reader should leave with a phrase, gesture, or artifact.
Keeps provenance visible while changing the material. Useful when the page should invite editing, comparison, and reuse.
The goal is not to make every sentence wear symbols. The goal is to develop taste: one marker can change the invitation, two can create a voice, and too many can turn the doorway back into a wall.
Sentence variety is nutrition for attention.
A run-on sentence often means the writer has more energy than container. The goal is not to punish that energy. The goal is to give it more shapes, so the reader can breathe, follow, and still feel the momentum.
The door opened. Use this when the reader needs a clear beat, a fact, or a landing place.
The door opened, and the room remembered us. Use this when two equal forces need to stand side by side.
Because the room remembered us, the door opened quietly. Use this when context should arrive before the action lands.
After the dust settled, after the shelves stopped shaking, after every label turned forward, the door opened. Use this when suspense should gather before release.
The room offered maps, jars, cards, keys, and one small bell. Use this when abundance matters, but the reader still needs order.
Then silence. Use this when the missing grammar is the point: shock, pause, afterimage, or emphasis.
The catalog wanted order, the children wanted dragons, and the librarian, who knew both needs were real, made a shelf for maps that could roar. Use this when several motives must stay visible.
A long sentence can work when each clause has a job, each turn changes the view, and the ending gives the reader a place to land.
newer writers often need more containers, not less imagination.
a draft has energy but every idea is arriving in the same sentence shape.
a page, scene, or paragraph with clearer pacing and more available voices.
A useful revision move is to mark the job of each sentence before rewriting it: #land, ?open, ~return, @move, .pause. Then vary the shapes until the paragraph has a pulse.
Structural Reduction Bridge
Spw is not the differential lambda calculus. It still benefits from the same kind of discipline: name the boundary, keep the resource movement explicit, and do not mistake a cleaner surface for a vanished obligation.
Workbench code gives this page a practical test: an operator should not only have a poetic name, it should carry a physics that can guide scanning, selection, replay, and composition. Measurement, potential, observer scope, merge pressure, value collapse, upward integration, constraint, measure, resonance, ground, and selector pressure are all partial moves in a larger calculus of attention.
That calculus is partial on purpose. A page, screenshot, prompt, or spell rarely transforms all at once. It composes by naming an input, applying a bounded operator, keeping the residue visible, and projecting the next state without pretending the hidden work disappeared.
Boundary-first reading
Good structure tells you where a block starts, what it depends on, and what residue survives after the local rewrite is finished.
anchor: operator philosophyWhy calculus belongs here
Integration by parts is a public example of the same structural move: expose the handoff, preserve the boundary term, and move the active differential burden.
route: calculus bridgeWhy resource sensitivity matters
Projection is not duplication. Interfaces, caches, rankings, and human attention all behave more honestly once duplication and displacement are named as costs.
route: differential lambda calculusWhy teams care
When a system gets simplified, someone still needs language for what dependency moved, what boundary stayed, and what work the new interface still carries.
route: algorithm visualizationOperator Ring
Use the ring as a compact comparison view. Every card gives you the token, the intent, and a route into the deeper operator page. The sequence doubles as a latent curriculum: resonance first, ground next, relation and possibility after that, then measurement, perspective, materialization, composition, constraints, surfaces, scenes, modes, and direction.
Spw Alchemistry
Transformation Model
Alchemistry is the transformation model for attention. Curiosity becomes a probe, relation becomes a reference, intention becomes action, action becomes stream, and structure becomes a surface only when the change remains inspectable.
Brace Physics
A brace marks where attention can gather without replacing the root. Opening { is objective boundary — shared structure you can inspect. Closing } is subjective synthesis — local consequence after traversal. Brackets [] hold discoverable variants; they are infix scopes, not postfix residue.
Charge may accumulate on entry and discharge on exit. Runtime phase and gesture charge are volatile; delimiter meaning is fixed.
Prefix / Infix / Postfix
Prefix primes before contact: !commit, ?ask, #>frame. Infix scopes the root: lens[probe]{wonder}, film[kitchen]{scene.metaphor}. Postfix marks residue after contact: commit!, closing }, settled ..
Fixity: delimiter grammar and data-spw-sigil-position are stable; capacity verbs are tending; data-spw-phase is volatile. Use @ for perspective, ! for action.
Future UI Surface
These pages are static first. Later, Spw blocks and scripts can use the same operator contracts to become widgets, inspect panels, spell boards, or LSP-backed navigation. When the semantics are explicit, the page can jump between the same root in different modes instead of flattening them into one label.
Cauldron workbench
This is a mounted experiment, not a finished product. The cauldron gathering system is public while it is still being worked on, and this bench tells you how to experiment with it, where to read its state, and what it becomes if the experiments keep landing.
? Invitation
You can try this right now: hold any charged term or brace target on this page and the cauldron begins gathering it as an ingredient.
! Experiment protocol
Tap a living term to prime it. Hold to capture it into the cauldron. Open the footer ingredients to see what you gathered; the cauldron hook jumps a captured note back to its living source on the page.
Everything is reversible and local: dismiss ingredients to reset, and nothing you gather leaves your browser.
. Reading surface
The experiment's state is inspectable: primed and candidate items respond to the cauldron visibility setting in settings, captured ingredients carry their origin context, and gesture charge is readable as data-spw-* attributes in your inspector.
& Elaboration path
Elaborate by remixing: gather a mix of ingredients that says something, screenshot it, or describe what you built through the contact path. Elaborations shape this atlas and the plan record that governs this bench — what previous readers built is part of what you are reading.
* Precipitation signal
Condition of arrival, not a deadline: when gathered mixes get shared back often enough to name a recurring shape, this experiment precipitates into a product form. The first named candidate is an operator deck — one card per sigil, with its motion, geometry, and symmetry partner.
$ Merchant path
Precipitates are sold by merchants in the community, not by this site — the site is the workshop and the reading room. The first stall stands in the town market. The standing invitation: elaborate a mounted technology until it precipitates, and the precipitate is yours to sell.
Semantic hierarchy
The site carries parallel ladders. Use the ladder that matches the question — do not collapse them into one flattened label.
Composition
page → region → feature → component → slot → module → chrome → runtime
Authored on body, data-spw-feature, data-spw-slot, and component anatomy. Runtime infers data-spw-composition-tier; it should not invent the public spine.
Expression
root[variant]{behavior}<lens> — root stays stable; brackets and braces narrow without replacing the stem.
Position + fixity
Prefix primes, infix scopes, postfix marks residue. Fixity runs cold → hot: fixed → stable → tending → experimental → volatile.
Grammar delimiters are fixed. Capacity verbs are tending. Phase and charge are volatile.
Cascade (presentation)
CSS layers resolve look, not meaning: reset → tokens → … → handles → effects → ornament. Semantic ownership stays in HTML, JS datasets, and .spw contracts.
Language evolution toward v0.4
Spw should become a compiler for meaning — not only readable text, but inspectable contracts that editors, tools, and runtimes can traverse uniformly. The v0.4 direction is expressed here in public language; the inspectable pillar artifacts live in the site .spw layer and precipitate into the workbench tooling after review.
Plain-text conventions scale best when the grammar provides uniform structural handles rather than requiring ad-hoc folder interpretations.
You need to know what grammar, indexing, claims, or projection work is next — before the parser lands.
Profiles, typed references, executable probes, stem projections, precipitated indexes, and a pinned workbench spec.
The improvement stack is ordered deliberately. Profiles and validation come first so file shapes declare what blocks are required. Typed references and indexing make dispatch traversable and broken links diagnosable. Claim and probe syntax turns hypotheses into falsifiable checks. Stem projection carries the same root into HTML, CSS, JS, and .spw without forking truth. Precipitates and register serialization let indexes and manifests become language outputs rather than ad-hoc scripts.
Index, convention, pillar, plan-index, and wip-notebook profiles imply required blocks. Test profiles in parser →
Typed ~" paths should resolve, project into indexes, and surface broken-link errors in CI — not only at read time.
owner_claim blocks carry hypothesis, spec_ref, impl_ref, probe_ref, and falsification. Test claims & probes →
One stem can precipitate into page copy, tokens, runtime datasets, and inspection surfaces. Test stem projections →
Plan indexes, agent manifests, and design catalogs should emit from register precipitates — not from one-off maintenance scripts alone.
Tight dots inside one brace are one identifier, not the crawl. Comma is common; semicolon is a schedule; ~> is a path. Test dot crawl →
Site pillars propose; spw-workbench on branch feature/spw-language-v04 proves. Pin the submodule after human review.
Priority stack
Profiles and validator → typed references → claim/probe syntax → stem projection → precipitate projections → register serialization → LSP lenses → grammar unification → runtime goals pipeline → core vs experimental namespace → submodule bridge.
Inspectable artifacts
Twelve pillar files under .spw/language/v04/pillars/ dispatch from .spw/language/v04/index.spw. Each pillar declares dimensions, owner_claim, language_delta, and validation probes.
Editor lenses
Show operation and fixity first. Go-to-owner must name an altitude. Do not build a wonder-aware query on an unpruned --from .spw walk. Harvest with npm run wonder; that list is inquiry, not a patch list.
What stays out of scope here
This section outlines the v0.4 grammar direction: unifying plain-text authoring with inspectable runtime and tooling contracts.
The rollout establishes public contracts and pillar specs on the site first, followed by formal syntax specifications and parser integration in the workbench tooling.
Language Reality & Vision
Spw in Practice: Proven Ground & Open Horizons
Spw is a living medium: the same notation on the page, in the parser, and in sidecar .spw. Hold a term. A join can be checked. The page is complete before any of that lights.
01. The Living Proof: How Spw Works Today
On spwashi.com, Spw serves as the single plain-text bridge unifying design systems, runtime interactivity, and agent pair-programming:
data-spw-* attribute projections, responsive container queries, and HSL semantic resonance tokens — without React, Vue, or client-side runtime dependencies.
.spw convention surfaces, 4,130 verified cross-references (100% resolve, checked 2026-09-04), and zero-dependency audit scripts (spw-integrity, wonder.mjs, spw-precipitate) proving semantic claims instead of merely asserting them.
02. The Mounted Tool: spw-workbench
Spw is not display-only prose dressed up as a language. spw-workbench is a separate, open-source parser and tooling project Spwashi built and maintains; this site mounts it as a git submodule at .spw/_workbench and reads it, rather than re-implementing a second parser inline. The mounted parser powers the literal parser tool; the site projects operator chips through its own HTML and runtime. The workbench also provides a CLI, a language server, and editor integrations:
spw CLI
doctor checks the mount and submodule pin; format enforces one canonical .spw profile; lattice, census, and graph read hub degree, familiarity strands, and reference topology across a corpus; mount, query, and select resolve citations and selectors directly.
textDocument/* implementation — definition, references, rename, hover, document/workspace symbols, completion, code actions, semantic tokens, formatting, and diagnostics — plus custom spw/* probes for reference graphs, register snapshots, and operator frequency.
nvim-lspconfig entry — one shared vocabulary projected through each host's own idioms.
Reflection, not a press release — this is what running the tool against this exact repository turned up on 2026-09-04: spw doctor caught a real drift (.spw/mount.spw still declared the submodule at a commit one behind its actual, cleanly-checked-out HEAD) and it was repinned the same session; spw format --check found 65 of 323 .spw files off the canonical profile (trailing whitespace, missing final newlines) and reformatting brought that to zero; spw:integrity, this site's own resolver built on the mounted parser's citation extraction, confirmed all 4,130 cross-references above still resolve. Not every signal was trustworthy as-is: spw graph's heuristic brokenTargets list named 43 "broken" citations that, spot-checked against source, were all live — an anchor-extractor gap in the tool itself (it doesn't yet recognize quoted ^"name"{} frames or absolute https:// citations), now logged in .spw/README.md rather than quietly patched around. The bundled LSP smoke suite (npm run lsp:smoke, run against the workbench's own doc corpus) currently passes 15 of 22 checks; the misses are open @root-resolution edges the workbench itself tracks, not gaps in this site's content. A tool worth mounting should be legible about what it gets wrong, not just what it catches.
Where I want the workbench to improve
The website is my test corpus. Consumer evidence lives in .spw/workbench-report.spw. A useful improvement makes one act of reading, navigating, or changing a .spw file easier to trust — and it does not invent a seventh wonder type to do it.
- Stop reading the same file twice. The cost is visible now.
spw query --statsshows that parsing takes 95% of a query on this site and that nothing carries over between calls, so checking every citation takes about 80 seconds. That is too slow for the local gate, so it runs nightly instead. The workbench remembers census and graph results, but it keys that memory on the hub count each command asked for, so census and graph never share a scan (measured below). Letting one scan serve query, resolve, lint, census and graph is the largest saving I can measure. - Make a stray backtick cheap. Files with a parse error are a tenth of this corpus and a third of its parse time. One unclosed backtick made a 32-row block seven times slower. A check that flags an unbalanced backtick before the parse runs would let a writer fix it in seconds. Bounding the parser's recovery would make the mistake cost what it should.
- Resolve a citation once, then share it.
spw resolvenow splits each citation into path and fragment and tells a missing file from a missing anchor. The next step is the same result in the language server, so the editor and the command line agree about what a reference points to. - Show what a change preserves. A geometry action should preview the actual source, name possible loss and offer a reliable return. Recovering the same text does not by itself prove semantic equivalence.
spw form --stdinis the contour that already taught this by hand. - Show operation and fixity; do not auto-promote. Filters could surface open questions beside stable contracts. Showing is enablement. Auto-archiving a cache is design. Go-to-owner on
data-spw-wondermust name an altitude — vocabulary, architecture, or doctrine — or it steals one. - Let the editor show what the server knows. The WebStorm plugin draws its own outline and folds with a line scanner, and the editor shows that copy instead of the language server's. The scanner loses a closing brace after an apostrophe inside a backtick sentence, or after a
#partway along a line; the server does not. The server's outline needs one fix first: it is the only request that parses the file again (measured below). - Give a repeated shape a form, and schedule the reading. A month of drawing prompts is a loop written out by hand: 31 frames with the same eight keys, and one plate of instructions retyped into each, 41% of the file. As rows it parses 58% slower. I would take a slower parse for a more elegant form. What a project should set is which files are read and how often: open files on every change, working notes on save, settled contracts once for each version of their content.
- Show what each way of writing trades. A quoted handle parses as one string, and the outline, rename and search cannot see it. Left bare, it costs eight more nodes and all three find it. Rows scroll shorter and parse slower; a
~"path"gets a link and an existence check that a quoted path never does. No form wins every axis, and that spread is the interesting part. Hover a value and read its trades. A quoted value that would parse as an expression could show as sleeping, one action from waking. A single speed score would flatten all of it.
What takes long, measured 2026-09-27. I timed every read-only Spw command against this corpus at pin 3eaab6377672 while other sessions held the machine at a load average above 160, so the ratios are the reading, not the seconds. Doctor answered in 7.6 s, format check in 5.9 s, lattice in 2.1 s. Census took 339 s and graph 436 s straight after it, and each wrote its own corpus memo: the memo key includes hubTop (24 for census, 12 for graph), so 28 memo products and 87 MB sit under .spw/gen/session/corpus-memo/ and no command has ever reused another's parse. Every call also boots through the tsx loader, about a second before a file is read, although the same parser already bundles to plain JavaScript for this site's literal parser. The fix is one sentence: key the scan on what was read, apply the hub count when the product is projected, and ship the parser as emitted JavaScript beside the TypeScript route. Receipts: .spw/workbench-report.spw#memo_key.
What one edit costs, measured 2026-10-05. I opened a 29 KB cache in the language server at pin 229aedcf9b6f on a quiet machine. Once warm, folding answered in 3 ms, tokens in 5, hints in 3, lenses in 5. The outline took 267 ms, and 510 after a one-word edit, because it parses the file again instead of reading the parse the server already holds. Inspecting the same file from WebStorm's Spw Instruments menu runs the command line on the saved copy, 2.9 s each time, while the running server can already answer form and resonance questions about the open buffer. Both fixes are the same sentence: ask for the parse that is already there. Receipts: .spw/workbench-report.spw#outline_reparse.
Sensors I would carry upstream. The CLI measures what the corpus is; this site's scripts measure what the corpus claims, runs and promises, and that second set is where the next commands are. A probe runner: 194 executable snippets sit across 59 surfaces and no tool has ever run one. A claim ledger: 180 owner claims, 150 probe references, 135 hypotheses, and nothing lists the claims without a probe. Expression kinship: 912 authored expressions parse, and the build precipitates their subject, mode, parts, projection, scope and charge for the browser, a table the CLI could produce for any corpus. An axes index: 371 surfaces declare operation, fixity and layer, and the linter checks the shape of the annotation while nothing indexes its value. A first-line review rule: 319 plan surfaces open with a dated decision because a site check refuses one that does not. Each is a script here until it is a command at a pin; the site consumes, it does not fork. Receipts: .spw/workbench-report.spw#sensors_to_carry_upstream.
Design targets a crawler should keep: consume the pinned workbench or experiment through web semantics — not both in one patch. [mode] keeps other postures discoverable; (scene) stages midprocess; a brace that does not teach a distinction is decoration. Page wonder is the seven types on the body; harvestable questions come from npm run wonder. Do not merge those inventories. Do not implement the harvest as a backlog until reading the corpus is cheap. Lattice that reports an empty field against thousands of appositions is worse than an error.
Reproduce a finding and carry a fix back here
Start with npm run spw:doctor. Reduce the slow or incorrect input to a fixture in the workbench. Test the smallest fix there, update this site's pinned revision, then rerun the original consumer probe. Enumeration, parse health and semantic validity are separate measurements.
In the September 2026 probe recorded in .spw/workbench-report.spw#walk_cost, the shared walker found 681 files under this site's .spw, including 374 mounted files; excluding the mount left 307. Default walks now skip the mount, and the doctor prints its scan exclusions. Aligning scan policy was useful, but it did not explain the timeout. The September 22 probe did: with the mount skipped, parsing is nearly all of a query (.spw/workbench-report.spw#parse_cost).
Read .spw/workbench-report.spw before proposing a lens. Open the workbench repository · Try the symmetry question
03. The Open Horizon: What stays useful
As software and models co-evolve, Spw stays useful when a claim can be tried, checked, and refused. The crawl prompt lives on spw.quest.
A compact notation helps an author or agent follow references and test claims. Sense first (npm run sense). Harvest questions with npm run wonder — inquiry, not a backlog. Explore/plan do not write. Spotify's Portal writing is the analogue: always-on context is I/O; a failing check is the block.
Cross-discipline teams (illustrators, animators, engineers, writers) can co-own a slice with a named contract that outlives a framework. One named slice per patch. Do not implement from a plan dump.
Arrival is a potential difference. Ink and light spend on the frame. Prove with a pocket still (npm run sense -- ink about-opening), not a metaphor that promises electrostatics as a product.
04. Partner, Build, or Commission
Whether you are designing a specialized domain-specific language, building a high-craft local-first web application, or establishing a durable knowledge architecture for your organization, Spw offers a proven blueprint.
Authoring Seed
#>spw_operator_page
#:surface #!reference
^"operator"{
token: "*"
intent: "flow"
interaction: "connect to dynamic or event-like content"
metaphysics: "attention becomes a current"
brace_physics: "stored charge biases the next projection toward motion"
}
?["What should tapping this operator reveal?"]{
fallback: "show the inspectable contract before any runtime action"
}The atlas starts as HTML, but the repeated structure is already shaped like something an authored Spw block could generate.