# Compound Expressions
#
# The grammar already carries compounds, projections and operator-led forms.
# The corpus now uses them sparingly: 14 compounds across 668 authored
# expressions as of 2026-09-04. The useful distinction is still a bond that was
# authored and can be tested, rather than kinship guessed from shared words.

#>compound_expressions
#:convention #!expressions #!electrostatics #!ecology
#:operation #!prime
#:fixity #!experimental
#:layer #!semantics

@semantic_expression: ~"./semantic-expression-consequence.spw"
@corpus_completion: ~"./corpus-completion.spw"
@electrostatic_affordances: ~"./electrostatic-affordances.spw"
@arrival_electrostatics: ~"./arrival-electrostatics.spw"
@region_ecology: ~"./region-component-ecology.spw"
@kernel_rhizosphere: ~"./kernel-rhizosphere.spw"
@operator_semantics: ~"./operator-semantics.spw"
@history_strands: ~"../caches/history-conflict-strands-2026-09.spw"
@manifest: ~"../../public/js/generated/spw-expressions.js"
@builder: ~"../../scripts/build-expression-manifest.mjs"

operation = "prime"
fixity = "experimental"

expression = expression[compound]{bond.operand.kind}<declared>

^"measured_disuse"{
  claim: "Every richer form the grammar offers is unexercised. This is the same shape as the apposition finding — 6 unit cells read across 237 surfaces while thousands of appositions exist in a form the tool cannot see. The site reaches for the simplest legal form and stops."
  authored = `668 parsed into the manifest (2026-09-04), up from 655 on 2026-09-03 and 441 before the utilization pass`
  compound_operator_joined = `14 — the newest is culture[context]{substrate;threshold;response}<residue> ~ arc[relation]{input;condition;consequence}<receipt> on the home current-direction copy. The visible paragraph names both sides: bounded living response and the mathematical consequence arc that receives it.`
  with_projection = `103 — grew from 88 on 2026-09-03; home hooks, labs, receipts, and the brace ladder now use the consequence seat`
  operator_led = `still ~1 of the manifest's 668; brace fit's ?copy[fit]{brace.select} plus a handful more authored in routes that did not survive the Capsule/Operation structuring gate`
  plain_subject_mode_parts = `still the overwhelming default — 654 of 668 carry no compound`
  ~#fixed(2026-09-03): "readShape in build-expression-manifest.mjs did not yet look, exactly as the original first-slice prime named. Verified: the manifest entry for the one real compound authored at the time (\"component[machine]{attention} ~ copy[hook]{wrap}\") recorded only the left operand — copy[hook]{wrap} and the ~ bond were silently dropped. Added readCompoundJoin to expression-query.js (shared by the runtime's shapeFromExpression and the build script's readShape) so a compound now carries both operands plus the bond kind (induct/subject/project/lens for ~/&/^/@) instead of losing everything after the first operator."
  ~#landed(2026-09-03): "6 more compounds, chosen by reading the actual page content on both sides — not backfilled from the shared-token census this facet's own refuse line warns against. Each was verified either by identical or near-identical prose describing the same practice, a shared data-spw-concept, or one side's copy naming the other domain directly. All 41 candidate groups that shared only a generic single-word part (orient, rail, stable, craft...) were left alone; sharing an English word is the coincidence @semantic_expression already infers weakly, not grounds for a declared bond."
  probe: `node -e "import('./public/js/generated/spw-expressions.js').then(m=>{const E=Object.entries(m.SPW_EXPRESSION_MANIFEST);console.log('total',E.length,'compound',E.filter(([,v])=>v.compound).length,'projection',E.filter(([,v])=>v.projection).length)})"`
}

^"separator_variety"{
  ~#note: "The dot is not a separator the grammar treats as meaningful — it is the tight-identifier case: parse() reads a.b.c as one IDENTIFIER token, the same way it reads a bare word. readBodyJoins only recovers list vs sequence vs name by which literal character the author chose, so choosing the same character for all three erases the distinction before the runtime ever sees it. 406 of 655 authored bodies (2026-09-03, before this pass) were dot-joined regardless of whether the content was a sequence, a set, or a genuine compound name — only 2 used comma, 0 used a real separator for a sequence."
  ~#tension(the tempting wrong fix): "; reads as the obvious sequence separator and is not valid Spw. parse() returns success:true on cauldron[garden]{sow;tend;harvest} but with two 'Unexpected character: ;' errors — recovered from, not accepted. The 2 authored expressions that reported join:\"ordinal\" before this pass did not do it through a real semicolon: both used data-spw-semantic-expression=\"...&lt;tradition&gt;\", the HTML-escaped form of <tradition>, and the ; inside &lt;/&gt; was what kernelJoinFromTokens's ordinal check was actually seeing. ~> (project) is the grammar's real sequence form and parses clean, spaced or not, inside a body or out."
  ~#fixed(2026-09-03): "two bugs the false ordinal reading exposed, both in build-expression-manifest.mjs only (shapeFromExpression at runtime never touches raw file bytes, so neither affected it): (1) the extraction regex read raw HTML source without decoding entities, so any authored &lt;projection&gt; both lost its projection field and corrupted its join kind via the stray ;. Added decodeHtmlEntities before parsing. (2) kernelJoinFromTokens's .parts for project/crawl is every IDENTIFIER in the whole wrapped `expression = subject[mode]{body}` parse, not the body alone — verified live: cauldron[garden]{sow ~> tend ~> harvest} returned parts ['expression','cauldron','garden','sow','tend','harvest'] before this fix. readShape now takes parts from chain (readJoinChain, string-only, body-scoped by construction) for project/crawl; ident is unaffected, since it finds one dotted identifier among the tokens rather than returning the whole scan."
  ~#landed(2026-09-03): "18 dot-joined bodies re-separated by what they actually are, chosen by reading each host's own prose rather than guessing from the words alone. 11 became project-joins (see superseded note below for the final separator): genuine chronology or causality an author's own copy already stated as a sequence — cauldron[garden]{sow.tend.harvest} (verb order is the whole point), brace[containment]{charge.prime.release} (the page's own copy renders it 'hold / prime / release'), concepts[circulation]{notice.name.connect.practice.return} (authored as a numbered <ol> on the same page), promotion[ladder] (a ladder is ordered by name), and 7 more of the same shape. 7 became , common-joins: independent fields with no inherent order — the six cards/index.html card types (card[ask]{need,deadline,budget} and siblings, each three unordered fields of one card type) and materials[spec]{paper,glass,matte,field} (a set of surface types, not a process)."
  ~#superseded(2026-09-03, same day, workbench f2e5b61): "; and || landed as real sequence separators hours after the tension note above was written — the tempting wrong fix stopped being wrong. Verified cauldron[garden]{sow;tend;harvest} now parses clean: Sequence, success, zero errors, zero warnings, where the ~> workaround still degrades to Prose (see .spw/workbench-report.spw#project_join_degrades_to_prose). Converted all 11 project-joins above to ; — every one of them is steps of one practice, not movement between distinct places, which is what ~> should be reserved for now that both forms genuinely parse. ~> stays correct for the worked example just above in this file (`scrap ~> mill ~> temper`) and anything site-wide that means an actual path. No readShape change needed for the ordinal case: its existing fallback to the regex-captured body content was already correctly scoped, unlike project/crawl's kernel-token bug fixed the same day."
  probe: `node -e "import('./public/js/generated/spw-expressions.js').then(m=>{const E=Object.entries(m.SPW_EXPRESSION_MANIFEST);const byJoin={};for(const[,v]of E)(byJoin[v.join]??=[]).push(1);console.log(Object.fromEntries(Object.entries(byJoin).map(([k,v])=>[k,v.length])))})"`
}

^"the_grammar_already_holds"{
  ~#note: "Verified against the parser, not assumed. Structure counts confirm both operands survive."
  induct_join: .{
    form = `component[technique]{expand} ~ spell[behavior]{cast}`
    structures = `Operation 1→2, Frame 1→2, Body 1→2`
    reads_as = `both operands fully structured — a true compound`
  }[reg=facet]
  list_separator: .{
    form = `component[technique]{expand} ; spell[behavior]{cast}`
    structures = `Frame 2, Body 2, but Operation stays 1`
    reads_as = `a sequence separator, not a relational join — the second operand is not an operation`
  }[reg=facet]
  also_parse: #[`& subject-join`, `^ project-join`, `@ lens (viewer@subject)`, `#> ground`, `nested bodies`][reg=set]
  consequence: "Compound expressions are available today. Nothing in the workbench needs to change for the site to start writing them."
  history_example = `History-conflict-strands names recurring repo bonds as compounds (consumer[walk] ^ workbench[mount], taxonomy ^ biome exchange). That is the corpus use this file asked for — declared relation, not inferred kinship. See @history_strands.`
}

^"declared_bond_versus_inferred_kinship"{
  claim: "This is what compounds are for, and why the ecology needs them."
  inferred: "@semantic_expression relates expressions that share a subject, mode or part. 423 of 441 have kin that way — but the relation is a coincidence of vocabulary. The part token `return` joins 21 expressions that may share only an English word."
  declared: "A compound names the bond and its kind. `A ~ B` says these two are coupled by induction; `A & B` says one is the subject of the other; `A ^ B` says one projects into the other. The operator carries the relation type, which inference cannot recover."
  electrostatic_reading: "@electrostatic_affordances defines inductance as kin of the same terminal sharing momentum. Today the runtime infers the terminal from shared tokens. A compound *is* the terminal — an authored coupling with a discharge kind already attached."
  rule: "Inferred kinship is a suggestion and should stay weak. Declared bonds are structure and may carry consequence."
}

^"microbiome"{
  claim: "An ecology needs typed relations between organisms, not a similarity score over their names. That is the difference between a population and a list."
  present: #[
    `@region_ecology — regions as material with personality`,
    `@kernel_rhizosphere — the substrate metaphor`,
    `@arrival_electrostatics — shells, walls, dielectric, discharge`,
    `expression kinship — inferred, weak, untyped`
  ][reg=set]
  missing: "Typed edges. Every relation the runtime acts on today is either inferred from vocabulary overlap or hardcoded in a catalog. Neither can be varied by an author, so neither can be selected for."
  what_a_culture_needs: #[
    `variation — bonds an author can write differently`,
    `heredity — bonds that persist in the corpus and are inherited by what cites them`,
    `selection — a measure that says which bonds earned their keep`
  ][reg=set]
  note: "The corpus already has heredity (citations) and a measure (probes). Variation is the missing term, and compounds are how an author introduces it."
}

^"what_to_write_next"{
  ~#note: "The first end-to-end slice is built. Keep compounds rare enough that each one remains a claim."
  landed: "The manifest records both operands and the bond kind. The 2026-09-04 editorial pass adds one visible cross-domain coupling: bounded culture response induces a consequence arc; recipes, math, research, and cards provide the receipt path."
  first: "Index parts by subject-mode pair — @corpus_completion needs the same pass, so do them together."
  second: "Let declared bonds outrank inferred kinship in expression-resonance. A bond an author wrote should light before a token two expressions happen to share."
  third: "Expose the right operand and bond consequence in an inspection surface before authoring another family at scale."
  refuse: "Do not backfill compounds across the corpus. A bond written to satisfy a convention is exactly the coincidence this is meant to replace."
}

#>wonder_compound_expressions_1
?["Why does the site always reach for the simplest legal form?"]{
  #:depth #!stylistic ~#lens(disuse)
  ~#tension: "440 of 441 expressions are plain, 6 apposition cells exist across 237 surfaces, and no expression carries a projection. Three independent forms, all available, all unused. That is a pattern rather than three oversights."
  ~#hypothesis: "authoring tools show the simple form. The template emits subject[mode]{parts}, completion offers modes for a subject, and nothing has ever put a compound in front of an author at the moment of writing — so the richer forms are legal, documented, and invisible."
  !probe{ "check what the page template and any snippet emit produce. if every generated expression is the plain form, disuse is a tooling default rather than a preference, and one changed template moves it." }
  $%[template.emitted, expression.form, completion.offered]
}

#>wonder_compound_expressions_2
?["Can a bond be wrong?"]{
  #:depth #!mathematical ~#lens(selection)
  ~#tension: "inferred kinship cannot be wrong, only weak — it reports a fact about vocabulary. a declared bond makes a claim about the world and can therefore be false, which is what makes it worth more and also what makes it a liability."
  ~#hypothesis: "a bond is falsifiable by its own operator. `A ^ B` claims projection, so if nothing in B ever changes when A does, the projection was never real."
  !probe{ "for each declared bond, check whether the operator's implied consequence is observable. an induction with no shared movement and a projection with no downstream change are both bonds that were asserted and never held." }
  $%[bond.kind, bond.operands, bond.observedConsequence]
}

^"validation"{
  probe: `npm run manifest:expressions && npm run spw:integrity`
  falsification: #[
    `A compound is authored and the manifest records only its first operand.`,
    `Declared bonds are backfilled to satisfy this surface rather than written where a coupling exists.`,
    `Inferred kinship outranks a declared bond in the runtime.`
  ][reg=set]
  next: "Inspect the new culture-to-arc bond in the generated manifest and runtime. Author another only when the visible copy names both operands and an observable consequence."
}