Spw.quest

Spw (pronounced “swoop”) is a position-agnostic symbolic grammar designed to formalize and modularize AI prompts. Core atoms (?,!,~,&,@,#,^,.) combine with operators (->, =>, |, merge, diff) and brace-first containers (() stage, [] state, {} config, <> preview).

Optional: a “photonic whitespace” model for phase-weighted layout. Default docs emphasize brace-first for clarity.

Backtick references `pkg://ui/card` resolve to modules/assets; labels/roles remain stable even when you swap operators or move them to end-of-line (postfix/EOL) and normalize back to prefix.

Each card advertises a stable data-component-id for tooling to scrape/export. Use these as patterns for UI composition or editor add-ons.

Copy^module[ui.base.card.v1]{
  props{title,subtitle,tags[]}
  theme{ bg:#linen border:#brass text:#ink radius:16 }
  a11y{ role:"region", heading.level:=2 }
}

Copy^module[ui.base.button.v1]{
  props{label,icon?,intent:=#primary,size:=#md}
  theme{ radius:16 focus:WCAG_AAA }
}

Copy^module[flow.sim.v1]{
  graph{ nodes:@actors|^anchors ; edges:ops(->,&,|,!) }
  simulate(step.ms:=33){ propagate; respect {} invariants ; draw<> }
  export{ .mermaid .dot .json }
}

Loads external Spw scripts from ./lib/. Edit ./lib/prompts.json to add more.

{}

Crawlable JSON endpoints used by the playground and branch pages.

• ./lib/schemas.json — schema bundle ($include physics/operators/containers)
• ./lib/prompts.json — master prompt manifest
• ./lib/media.prompts.json — media prompts
• ./lib/text.prompts.json — text prompts
• ./lib/pe.prompts.json — prompt-engineering prompts
• ./lib/operators.json — operator index

Copycurl -s https://spw.quest/lib/schemas.json | jq .
curl -s https://spw.quest/lib/prompts.json | jq .
curl -s https://spw.quest/lib/operators.json | jq .

Quick-copy seeds or fetch the JSON blob below.

Core

Copy^prompt[spw.seed.core]{
  purpose:"Introduce Spw and enforce clarity",
  style:{structure:"Goal | Ingredients | Steps | Result"},
  syntax:{atoms:"./lib/schemas.json",root:"^"},
  guidelines:[
    clarify_only_if(ambiguity),
    flag{consent,accessibility,eco},
    forks{6mo,2yr,5yr}
  ]
}

ai.media

Copy^prompt[spw.seed.ai.media]{
  imports:^prompt[spw.seed.core],
  module:"image/video/audio",
  defaults{?model:"Midjourney v7",aspect:16:9,quality:"high"}
}

ai.research

Copy^prompt[spw.seed.ai.research]{
  imports:^prompt[spw.seed.core],
  module:"lit-review,data-analysis",
  checklist &[
    search_lit, extract_citations, generate_summary
  ]
}

Master Seed

Copy^prompt[spw.seed.master]{
  modules:[
    ^prompt[spw.seed.core],
    ^prompt[spw.seed.ai.media],
    ^prompt[spw.seed.ai.research]
  ],
  boot!:true
}

Copy? ! ~ & @ # ^ . ( ) [ ] { } < > : | -> => = merge diff
⟶ ⟺ ⟡  //  /* meta:key=val */  `pkg://ui/card`

Tip: many unary operators may appear at end-of-line (postfix/EOL). The evaluator normalizes them to prefix on the preceding closed brace scope.

Canonical map of operators: ascii/utf8, name, arity, fixity, precedence, associativity, and normalization policy.

Copy^index[operators.v2]{
  // unary (prefix or EOL-postfix)
  op["?"]{ name:"query",   arity:1, fixity:["prefix","postfix:eol"], assoc:"right", precedence:90 }
  op["!"]{ name:"imperative",arity:1, fixity:["prefix","postfix:eol"], assoc:"right", precedence:90 }
  op["~"]{ name:"approx",  arity:1, fixity:["prefix","postfix:eol"], assoc:"right", precedence:85 }

  // binary (infix or EOL-postfix-as-curried); no forbids
  op["&"] { name:"bind",   arity:2, fixity:["infix","postfix:eol:curried"], assoc:"left",  precedence:70, curry{enabled:true,dir:"left"} }
  op["|"] { name:"pipe",   arity:2, fixity:["infix","postfix:eol:curried"], assoc:"left",  precedence:60, curry{enabled:true,dir:"left"} }
  op["->"]{ name:"route",  arity:2, fixity:["infix","postfix:eol:curried"], assoc:"right", precedence:55, utf8:"⟶", curry{enabled:true,dir:"left"} }
  op["=>"]{ name:"mapto",  arity:2, fixity:["infix","postfix:eol:curried"], assoc:"right", precedence:55, utf8:"⟹", curry{enabled:true,dir:"left"} }
  op["="] { name:"assign", arity:2, fixity:["infix","postfix:eol:curried"], assoc:"right", precedence:50, curry{enabled:true,dir:"left"} }
  op["merge"]{name:"merge",arity:"2+",fixity:["infix","postfix:eol:curried"],assoc:"left", precedence:45, curry{enabled:true,dir:"left"} }
  op["diff"] {name:"diff", arity:2, fixity:["infix","postfix:eol:curried"],assoc:"left",  precedence:45, curry{enabled:true,dir:"left"} }

  comment["//"]  { class:"sequence_fence", lowers_to:"|", note:"A // B ≡ (A) | (B)" }
  comment["/* */"]{ class:"docblock", materialize:"{meta}" }
}

Policy: brace-first → operator normalization (EOL→prefix) → precedence/assoc. Binary ops are not permitted as postfix.

Use this when spw.quest itself is your prompt. It communicates design goals and operator mobility.

Copy^prompt[spw.quest.system]{
  role:"system",
  design_goals:["brace-first","operator-mobility","backtick-atomic","WCAG-first","energy-aware"],
  operator_index:"./lib/operators.json",
  evaluate:{
    normalize:"@runtime.fixity.normalize",       // e.g., ["curry_postfix","eol_to_prefix"]
    curry_profile:"@runtime.fixity.profile",      // e.g., "left_curry"
    placeholder:"_" , preserve_backticks:true, docblock:"/*…*/→{meta}"
  },
  instructions:[
    "No forbidden postfix. Treat binary EOL-postfix as a curried function per runtime.",
    "When ambiguous, defer to runtime profile rather than hard-coded rules.",
    "Keep labels/roles stable across operator position changes."
  ]
}

Copy// sequence fence: A then B
A // B   ≡   (A) | (B)

/* doc:locked, credit:@spwashi, alt:"Specimen" */
^scene{ meta{doc:"locked",credit:"@spwashi",alt:"Specimen"} }

Copyscheme://mount/path :selector #tag ?q=val
fs://src/ui/ui :theme
pkg://ui/src/button :render
@icons/bell.svg        // alias → pkg://assets/icons/bell.svg
`pkg://ui/src/card`    // backtick ref (clickable in editors)

• Generic algorithms • zero-cost abstractions • iterator-first
• Value semantics • small composables • predictable latency • WCAG-first
• Version gates: experimental → incubate → stable

Speculative modules to model attention, agency, and ecological constraints in prompts.

Copy^module[attention.field.v1]{
  ~budget{ focus.ms:=800, breadth:=3 }
  bias{ #gift:+2, #quarantine:-3 }
  spell.focus(seed){ () recenter ; [] persist ; <> explore ; {} lock:on }
}

Copy^module[eco.budget.v1]{
  energy{ tokens:=1024, latency.ms:=500, cache:true }
  policy{ WCAG:"AA", consent:"opt-in", reuse:"prefer" }
  gate{ if usage>budget -> ?review -> !throttle }
}

Copy^module[metaphor.layer.v1]{
  map{ !:spark  ?:gate  &:clasp  ^:keystone  .:lens  @:badge  #:stamp }
  speak(card){ () brisk ; [] steady ; {} formal ; <> tentative }
}

Goal | map Spw utility across domains → copy-paste seeds you can adapt fast.

1. Prompt eng: atoms (? ! ~ &) + braces → clear IO, constraints, tests.
2. Cognitive scaffolding: ladders, tags, trails → staged recall + transfer.
3. Scene design: cast+space+time as typed slots; previews <> for fast iteration.
4. Event description: timelines, diffs, invariants; replayable “why”.
5. Game design: entities, state charts, quests; reward/value piping.
6. Modern tech: stable URIs, JSON-LD mirrors, CRDT-safe merge/diff.
7. Linking/tagging/breadcrumbs: `spw://` refs, @tags, ^trail for sense-making.
8. Quantum language: superposition→collapse semantics; entanglement via &.
9. Crystalline design: lattice templates; facets = reusable views.

Copy^utility.map[@meta{author:spwashi, date:2025-08-27, v:0.2}]{

  .prompt.engineering =
    ^prompt[goal|context|constraints|io]
      (?ask) (~tone:warm) {tests:`spec://unit/1`} -> => (!deliver);

  .cognitive.scaffold =
    ^ladder[(recall)->(apply)->(transfer)] @tags[spaced, multimodal]
    ^trail[spw.quest > atoms > braces > flows];

  .scene.design =
    ^scene[who:Actor, where:Dock, when:Dawn, mood:mythic, props:[mirror, letter]]
      <>preview("fog + gulls + unanswered questions");

  .event.description =
    ^event[timeline{
      t0: state[], t1: diff{mirror:=“forget-hint”}, t2: merge{Actor&Letter}
    }] ^axioms[no-violence, consent];

  .game.design =
    ^entity[Courier]{stats[focus:3, nerve:2]}
    ^statechart[(Idle)->(Route)->(Deliver)->(Reflect)]
    ^quest["Only deliver unanswered questions"] => ^value[insight:+1];

  .modern.tech =
    `spw://lore.land/scene/boon/001` #hash(sha256)
    {jsonld:`schema://CreativeWork`} (crdt.safe: merge|diff);

  .link.tag.breadcrumbs =
    @topic[boonhonk, pedagogy] ^trail[boon.land > pier > letters];

  .quantum.language =
    ^superposition[reply:{A:"joke", B:"poem"}; ψ{A:.3,B:.7}] !measure => "poem"
    &entangle(Actor,Mirror){state:reflective};

  .crystalline.design =
    ^lattice[12-col grid] ^facet[card.scene]{slots[title, mood, actions]}
    ^cleave[rules{AA contrast, reduced-motion}] ^dope[palette:teal/cream].
}

Result | portable seeds for prompts, pedagogy, scenes, events, games, and systems—WCAG/consent-aware, CRDT-friendly.

Micro-exercise | swap any block into your current repo and note one Δ it reduces (ambiguity, drift, or toil).

Select blocks and copy them as one gist—great for pasting into chats or repos.

Try file/URL ingestion, share prompts, and export components. Drag-and-drop files anywhere on the page, or use the buttons below.

Hint: hold Shift while dropping files to append instead of replace.

• Cadence: weekly chore pass, monthly minor release, quarterly meta review.
• Contracts: {} is canonical; <> cannot downwrite {}; WCAG AA or higher.
• Ops: token & latency budgets; scripted diffs; preview gates for risky patches.

Copy:root{
  --accent:#194563; --surface:#eef6fa; --radius:16px; --gap:1.5rem;
  --shadow:0 2px 8px rgba(0,0,0,.08);
}

1. Operator-aware autocomplete (& snippets) in playground.
2. Flow sim view: render .mermaid and .dot exports inline.
3. AR conlang adapter: gesture→operator mapping demo.
4. Seed packer: export .spwpack (manifest + assets).