flywheel could eat|spew energy from|against jiggles

[stylehouse.git] / G / Lafr / a

2024
mo Jan 1
  on the coast in Island Bay, the Cameron clan
 tu
  run around, find Steve H
 we
  Dunedin again, meet Bip
 th
  more violing
 fr
  far out it is friday!
  note on wholeness of our bop() computation
 sa
  big violin session
 su
  TestBetimes.svelte
   half harness
 mo
   generate_diff() works on a a set of named bloubs from Recolink_discovery(),
    which we need to mock also a /treeh/* phase to get
   write a test situation
 tu
   fix Betimes() grouping seeming off-by-one
    the first thing of the later group being grouped in the earlier group
    by stopping the test situation at the point that happens...
   keep the earlier of merged sy&be%time
 we
   now grouping good, at the +16 gap in a long stretch
  do a bunch of cleaning, Nat back tomorrow
 th
  TestBetimes.svelte
   turned on Kom%diff caching
    this seems to slow us down? need proper perf tests.
   discovered you cant do any async in map()
    unless you wrap it in Promise.all
     which the throat could do..?
  get some nice fresh Nat food! she arrives in TWO HOURS!
  Con|Cont investigation:
   it seems Con.t='treeh 15' once we get to Cont.svelte
    after being Con.t='6' when we check for Con.t == Cont%Ct
 fr
mo Jan 15
  figure out where Con.t changes between step1 and Cont.svelte (in Inspherical)
   indicating I do not do enough revision of recently invented parts
 tu
   Con%avoid_restating_Ct hacks to not double-label it,
 we
  car battery dies while I am wiring the stereo for always-on-ness
   was a scary thing, running out of car in NZ
   battery charger charges battery!
    just too much appliancing while parked
 th
  perhaps G.ts needs splitting to:
   N.ts - having a set of news
   W.ts - news vectoring to|from some backendistry
    could we simply integrate: https://willowprotocol.org/
 fr
  unknown
 mo
  other
 tu
  car maint
 we
  went Tokarahi, Pareora
mo Feb 5
  hay hay hay
 sa
  there emerges a need to type into somewhere intelligent
   and sort out the multiple threads of tracks
 mo
  Willow protocol might be able to:
   store|distribute
   naming schema
    replaces certain ip|t+ with a shorter version of itself?
mo Feb 19
  come back from Burning Horse
 th
  think of plants to take to the country:
   little tagasaste tubes
    only the runts left, not tall enough to not get lost in the grass yet
   low comfrey
 fr
  trying to make lda happen.
   no good results yet.
   < read a tutorial on this area
   make graph distance after lexing for ... is all we need.
 sa
  feel vaguely sneezy. maybe its covid?
   maybe its my music stuttering at about 5hz
  javascript names can include $ and ZWJ
  mastodon gets spammed by Japanese middle schoolers
   somehow @academicchatter boosted them
 su
  onthe pissnshit
   the loo has a 60L basket|bucket with a torus of hay in it
   an almost-hoop (C) with hooks along it envagenates dumpings downwards
    like a hay vortex that eats whatever is put in it
   once the donut of hay is worn out the whole thing gondolas to a nearby container
    which bites the load out of it, reloads with hay and returns
  onthe shelter
   a geodome with clear silicone triangles buttoned taut
  onthe weeding hook
   the last iteration at Pareora was pistol-gripped, not tested by me
  the expanding Kom//Kom
   filling in reality
   must be the comparitions via various algos...
    LLM is likely much better than LDA
 mo
  total dismay. maybe its covid?
 tu
  lets get Kom
 we
  I need a nice editor for my writing
   having components "in" codemirror seems like it
   and many of its chunks can be merely links to more
    links or likes?
     a like should contain a picture of what is being liked
  Gemini and perplexity.ai does the best up to date research
   eg for "in 2022 Aotearoa/NZ imported how many tonnes of animal feed"
  it has to do types?
   variable names are types
    where we can abstract whichness
  
 
  Kom|Rec
   basket structure to store in Willow
   times-Kom should happen, over time
    its replacing innard sequentia
    
  < multi-group intersections of info
  < neighbourhood hotwater radiator scheme
  < mix a soft and easy way
     left to choose its path
     will always be a friend
  < Toko
     nitrogen pile
     sodcutter? to get through whatever is in the back
  < turn on animation for going commits
     we want the lines of diff floating into the new commit...
     too complicated!
     need to get to the point of functioning code editor
  < limit geometry in some standard way... afterUpdate measuring tapes?
  
    
    < make the novelty Knob more accessible
     < animated labels for things (eg the novelty Knob) ~~ fireworks under mousehover
      < classify a few types of gesture, eg hover, winding, log, scale
        and time, as the enclosing thing (Betimes) is about
        we want also to classify text in a way that makes it work for any language
    
   < hack in chaptering to Betimes()
     ie, replacing kommit/atreeh+ with kommit/akommit:ning,
      and to read such a ning
       you inline ning/* to kommit/*
        which provides the caving history
         may recurse all the way back to somewhere we know
         repeating further links every 10 kommit/akommit,
          which are fine grained steps of change arriving
       apply any later kommit/treeh$n
        to reconstruct state movements
     so you should be able to trace your way back to the time you have
      when incorporating ~ from W time++
      
    < Story/$t loader? or just as a programming aid for now?
  
  
   
  < Be~times taking over cull
     it should know when things are no more
    which is usually regrouping commits
    based on analysis:
     < merge small %delta
     < similar diffs
     they should occur in sequence of course..?
    and:
     -Rec%msg|%level
      where the user hangs meaning
   
   a stabilisable space to splat cytoscapings (NO)
   place to name segments of time
   snip ties to garbage (and other link-net problems)
   and run reset operations...
   
  Record C|B
   -Kom latches on for naming
   < indicate time between times
   < make tiny diff texts
   < -Kom annotates times/-Rec, namable
      which /kommit/ should keep longer
   <<<
     group near activity
      probably for further than /kommit/ does
     feed it into cytoscape? no! resist!
     this is a change time-series
      the change can be computed by treating them as branches and looking things up
      mostly about grouping near change in space+time
     
     /show
      just the relevant -Rec nibs, expandable
      do perhaps a second Construct for /show?
       to i_() them in there (without changing .y.up)
      and overlay branch correspondence
       ie, ability to name any of the objects
        and decide when that name no longer applies
         call these streaks?
      so -Rec may not exist as .svelte
       and do its compute in Construct?
  
  
   < one unified link to change in sessionStorage
   < read that back on Record init
     all /in/* wanted must show up
      see Code/** stored and thawed
       then we can call it Code-protocol and
    < reversing the flow of everything...
      io expressing the pathway
     < tag pulled-over /in/Diring Reco
       we might
        only want to do /in/Diring
        undo it or bits of it
        give it local adjustments it didnt know about
         ie merge things we should keep
          determined by them sharing history?
   < Code/** stored and thawed,
     convert to -Record, -Codemirror and saved in there...
      specify their own names? paths?
     would then have a rearrangeable component hierarchy
      no more piling features into Code itself
      and we could manage send|receive for things within things
  
  < a resolve $n shrine, to pamphletdrop on peers
    for a computation that updates a set of things, where the things might have moved or changed, and we interpret them as they are presented again and eventually have shape enough to find the difference from last time, and match new with old quite well usually.
    What is that called, how do people deal with the dichotomy between unfoldment and adaptation to change... Eg you cant be sure of your grasp of the input data until the highest levels of the new situation are available for comparison to what they were 'before'. It seems the two states must be fully aware of themselves
    Every field doesnt get fully sure where the particle is. Computer avoids meaning with unique ids, the opposite of merging informationally, to arrive us to the future.
  < test o_up() d.til|all|until + inc + sing
   < and other such exercises via a Story mechanism
    < showing the inlacing Con as code graph
    < explore time, A branching
   < standardise (in St.ts?) all the C%z manipulations we make in G.ts
   < io (Sarg?) using the above
      various ideas.
       eg a leg could be a function, producing|consuming the surroundings
        https://www.w3.org/TR/xpath20/#id-function-calls
  < better abstractications:
     -Rec may sc&real (Lines encoding) and sc&been (save coordinator)
     < io expr that they %encode, without it ending up on the Lines
     
   < the Reco+ and around|been/* serial-numbered lists
      are the same things. see Recolink_stillness
     s-Rec%N=[Reco+] should become s-Rec/r-Reco
      so the "I want this version" UI can work the same on either
      
     perhaps this first will break down the testing load...
         
     
    < cull lists (around+be) of unstored things...
      they dont seem to occur any more?
    < errors
    
  around Record
    
   Diring/-Dir**
    < point -Dir also at files themselves...
      cargo /peek/ from serve.pl to serve.py?
    < g.o our first resume-from-Record
   
        
    # < in order (slice the rest)
  
  Babz $art -> var art? or let art?
   I might be surprised by subtle changes in 'The' then
  < Sunpit should match IOing > SunpitHead
    needs to get locked in at "S o "
    wrote in about this:
     https://discuss.codemirror.net/t/no-backtracking-after-some-convincing-point/7357
     more reading the docs is the answer
    
    
  < having an interactive nice place to control the computer...
    to do the various experiments with novelty detection etc
    a data scientist perch
  < cytoscape the pictures, so tendrils of them can be climbed
     clump by time, qualia
    do I need p2p sqlite for that...
     does that make network traffic traverse the router?
    
   
  < Knob|DropDown should be savable
    I guess everything needs to be a G?
     can it use hooks to know when everything is rendered?
   < add hierarchy to the syntax nodes on the line...
      have to dedup cursor.name|from|to ?
      while climbing everywhere from all of them?
   < add the line itself, broken down to what we have
   < composite graph (nodes inside a node)
      be used to show grammatical nesting good...
   < following lv (C** news) for look**
     so we can only add|remove what changes in the graph
     to write a Story: things to be fed in at time+1, etc
   < symmetry of line <-> schemes on it via cytoscape
   < https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API
     using Aip to start a negotiation to move a thing?
      various tendrils will need to come about
  
   in Co, inlacing layers out a little pile of data visits
   or which of these functions in Co.ts call each other
    they seem to want to be mindbits
     and we define how to time visiting */* for DCresolve() etc
  < subulate Co.ts, naming things
  < make a graph of Co.ts
  < ipfs storing everything > 1 minute
    Savable > 1 second, and ipfs addressbook|shrine|keys?
  
  < deploy statica https://www.okupter.com/blog/deploy-sveltekit-website-to-github-pages
  < allow components to emit modulat...?
     by phoning G whenever..?
     wanting to be SSR?
     
  Planet|Ying|
  < bring Lines, transmit data to the host...
      look at Lines
       lets copy it out
        remove yaml encoding, use json
         to find an encoder that can stop quickly when it gets too big
          I modified a yaml.js for ive-era code
           # I dont label eras of stylehouse very well
           #  we should go on a novelty hunt through the symweb
       
  < use Lines to start a bunch of islands of activity
     waterfall code through lezer to Stuff.ts
    adjust job speed
    
    
  
  
  < code search
    as a way to begin ghost->codemirror
    
    https://xata.io/blog/postgres-full-text-search-engine
    load up ghosts via codemirror
     partition by lang: spec|comment|code
     and of course time, git-blame can expand
  
  < it needs a tapedeck and patchbay rack
    to then geometrise
    load from store
    
  < expose ghosts/G/*/:t as $t.stho
     hmm...
  
  < an editor to replace this Codap thing
    all of Text should be importable now
    
  < into codemirror:
     Compile output
      nest alternations nicely...
      with sourcemap
       (must have been done?)
     Dir listings, Vid listings
      moments + text = thing
  
     
  
  < LieSurgery
     edtior, ie new Codap
     one cm per screen (scrollbar is too shared now)
      it focuses on the headings
       nearby visitations sit as time-twisted filaments of headingses
     would be great and easy to escape vscode
     a lot of stylehouse could be decoration around an expr in cm
      can it phylogenate its tendrils? (lines)
     having a data visual the can copy out as Lines or C
      getting people to select things is dodgy
       we should move to a circling scheme.
        the not-it can be preened off the data
         data falling over the disinclusion line ghosts away slowly,
          so one might bring it back
           making it an exception to the rule
            and perhaps the rule becoming smarter
             see "a multiple select should find language that expresses it"
     
  
  < get this wireless dongle more than 1ft away from my head!
     https://www.instructables.com/Share-WiFi-With-Ethernet-Port-on-a-Raspberry-Pi/
   < sell these... half a cat5 to esp32 wireless 
     
  < split the site up:
   < /G/The etc prototyping:
   
  < once Dir is d>3, you must +2 boost the previous thing, then ring()
   < this should be about Eing
  
  < some draggable
  < ssh swampdirt - can svelte via onion perhaps?
     it is 10x the cpu as this laptop
      https://www.cpubenchmark.net/cpu.php?cpu=AMD+Ryzen+7+3700X&id=3485
      https://www.cpubenchmark.net/cpu.php?cpu=Intel+Core+i5-4210U+%40+1.70GHz&id=2259
     then I had a desktop:
      https://www.cpubenchmark.net/cpu.php?cpu=Intel+Core+i5-3570+%40+3.40GHz&id=827
     
  
  
  < store it in an ipfs-ish hash key -> value store
    will it cull sensibly?
     we just have to request everything more regularly than the pile builds up
    store state when the url ?h=...&... becomes too long
     providing routes for when an uncommit state gets renamed in clients?
      breaks encryption, have to have it done by someone near trust
      hopefully as the convo goes on such history can be sealed at some point
     
  
  
  
  
  
  physics inspiration
   https://paveldogreat.github.io/WebGL-Fluid-Simulation/
    how it would oily-crumple things around it
   https://en.wikipedia.org/wiki/Iterated_function
    nice picture
   "Phases are single-pass, forward graph walks where possible"
 
    
   music -> tablet @labour
    mkdir "Rahsaan Roland Kirk - 1976 - Other Folk's Music"
    cd "Rahsaan Roland Kirk - 1976 - Other Folk's Music"
    dir2ogg "/media/...Other Folk's Music (Atlantic Records)/"
    mv "/media/...Other Folk's Music (Atlantic Records)/"*.ogg) .

   < AI
   < transmission-gtk oughtta
      let the default download location change
      old (and well seeded) cull workflow
   < a monitor that changes brightness depending on the time of day
      via buttons it has these settings: Standard|Internet for bright|dark
     I am often glaring by night and sometimes left with a mysteriously dull morning
  

   < branch layout:
      turtle moves in letter shapes for compute carpentry vocab
      tunneling|folding away, open causing closes
   < overall layout: screen splitting
   < build Le interfacible, like boost
   < reset_tocon to become a disassociation of rowing
     sipd need not reset since .setN() goes goners
      in io parlance,
         sipd could be cascaded to since it looks at history
          as opposed to holding history (3d vs 2d view)
          alluding to a slant, viewing-angle perceptex
   
   < video editor via python api?
      interesting:
          fl_time(self, t_func, apply_to=None, keep_duration=False)
            Returns a Clip instance playing the content of the current clip but with a modified timeline, time t being replaced by another time t_func(t).
          moviepy.video.tools.segmenting.findObjects
          moviepy.video.tools.tracking.autoTrack
   
   < loosen the input to Con... drag other items into it?
   
   < permanent sips, where earlier positions are inserted to via 0
     
   < tocon makes a datadump C**
      then generate lv for changes
      over time, as various t are increased
      thus making Story
   
   < pull out all dispatch mannequa?
   < Cont / onMount / getBoundingClientRect
     might help draw fibers of:
   < Eref noticing when objects are the same
     do we need an E for every C?
      follow its C.y.D when it turns up?
     try using WeakMap
   < $page.url.searchParams from '$app/stores' sounds nice
     Storing state in the URL!
     cant quite work out how tho
     accessible from +page server only?
   
    
   
     C|A <=> C saved.
  
    dumping into codemirrors that can be widened...
     we must get away from the one-way-out of html rendering R
    such also shall mark grammatica from Le
   play
    soothing animation, form nice
     composite images
      is canvas faster than things.
    elements with slots to put grammar->A
    elements for arranging before, eg into:
   getting the numeric type-pad torus sorted, ie wittershins spiral 1-9
   1 C
   2 know something
   3 connective situing
   4 conditions of the heart
   5 the plan planes ply
   6 the algorithm wanders
   7 what we need to keep to do it again sensibly
   8 talking of its role amongst all, honing itself
   9 speaks of its replacement with some other forming ideasmesh, honing all
  some FreeCAD for the "summer projects"
  
  
  < flipping times off|on needs to be easier
    can bun fork? park fresh realities around this one, experiment with them
  < Conbustank summer metal project, nice plan 
  < lezer parses Lines and Codes
    they may appear within each other
 <<< 
  sense of time
  lets read all S io in Adju
   put them together to form a logicality on &Ro|i|a
  we are rebuilding the toplevel
   with the tech:
    the G&S needs to be
     so we can fling A without A&Sunpit at Sunpits
  all this 
   showing a great bunch of io lang promises
    eg ch** ending at ch%edge (along a slope)
     yet being able to want ch~~def inside there also
      ie knowing which lines to inflate meaning around
      see > lazily split chunks that far in as needed
    eg sorting by line any use|def
     which may get into the use/onl.lin
    needs:
     aggregate syntax, see ahk(line_uses,[onl.lin.s_line],use)
    the i of selections, such that the non-selected shade
     eg X.selected for ch**, ch%defs_selected for /def
      sometimes given by eg def.uses
    and unifying to one
     over ch**/def...use
      where ch** can go beyond ss&edge, inside /def
       since a /def is a chunk written up as a defined routine
     
  some at a time? scrolling toc magnification
   < the rest of link_def_use:
     < soundpooling: is some depth of ch**
       that all defs|uses will be indexed to?
        would help s** narrow its focus
     < some lv-ish input for this also?
     < -is of course presents a ghost with such expression
      < ie, find all uses of such defs, etc
   
   
    < this all wants io definition
      if everyone uses of=fi, it should encompass them all...
      brackology.
   < should be doing more in A:Fish, only dumping data into R:Piing
      has errors that curse This**
     so This** might be used to Arrive before
   < a throat for these ch that want to lay about then wind up
      mind to use = A&t || A.t
      possibly many
   
  < guitars less glue
  
   < draw the non-concise %first_line around %title
   < rename chunks, detect clashes|scope
   < save TXing.. to -Lab?
   < which leads into rebundling $me for futurised R
   
  < expand proto @is
     it adjusts expression of a pile (of code)
      to a point, subselect, etc
   < Leopardo-Eight/3/-is
      to make display
      codes into A/chunk,def
      use %TX for pointering
       harvest them into T.adj form...
     
   < Leopardo-Eight/3.1/-is
     # the YA:Leopardo runtime opinionation...
     #  this is what @Pro would know about it
      < try just a Fishpit that can re-Go whenever...
        it has to hang off Sunpit
        < Yingumap time slices that can redo
     YA:Leopardo
      each &YA,'Leopardo' (t,y,c) -> g:YApit
       an occasion to it
      # these are Fishpits: &Fishlive | Fish.S()
      1|Yc&main is Leopardo@1
       # these are YApits
       &fetch
        # these are YApitpit, to ~~ !gh and return
       sleep
      2|Yc&doing is Leopardo@2
       big compute of our This**-is
      3 is Leopardo@3?
       downstream relaxes etc if -is%dige same
      
      so from the top
       # these are Fishpits:
       S 1 we wander into
        begins defining and doing YA:Leopardo
         until the Run needs async, in the &fetch YApitpit
        it goes async, retries from T.again_later:
       S 1 syncs, just to get &elvising on from &fetch
        ends up redoing YA:Leopardo to completion, so:
       S 2 next
        adds another YApit to YA:Leopardo
        <<<
         and we decide to do it now
         
         or whenever:
          if eg @Intro notices change in chunk:
           Sunpit/Fishpit/YApit
          we should come back to S 2
           to redefine Yc&doing on the &way in
      
      so Fishpit
       are essentially when A.4 can do things
       one seems to handle 4%todo|&elvising
        ie, one Fishpit being main()
         being our default ceremony of Attention, &elvising
       
       Attention may be externalised, when we want:
        < just &elvising on its own pseudo-Fishpit
          we are still calling through the &way
           the Fishpit instanced for i This** etc
          eg &syncserve via W&GoPara
           seeks a Fishpit, does a callback instead
           leading vaguely back to what it was doing
           by that callback making 4%todo++ -> 4&syncserve()
        < reset Leopardo@2
           Go Fishpit/YApit
           replacing its This**
            This...-Eight from it can reset just in time?
           Y&X
            Y&X needs reset (clone X.$parts) from Leopardo@1
             ie each YApit a dome unto Y&X
            Y&V keeps the parent version
             < fullest (Leopardo@3), or as it was last Leopardo@2?
             so the previous Y&X is forgot
               as opposed to turning into:
              the previous Y&V still is
             unless
              we want the procession of Y&X(->V)+
              to include all this code++ reset
          then forwarding to Leopardo@3 if changey
           or eg perhaps the ghost changed
            but where we were looking didnt
          
          Y&X reset
           X/$parts/$things appear to io as X/$things
           so parts can be switched, recomposited...
           a reset:
            check out Y&X, clonily
             we want Y&X as it was starting eg Leopardo@2
              a complete Leopardo@1 we can i
           
           some weird backendistries near here:
            > 
             we can know X/ghost never gets i by Leopardo@2
              and simply adopt: x.up=Y&X
               < transact
              perhaps keep only one extra copy of x**
               in case this time it does i
                we would still have the previous
            
            > 
             X/$chunk causing X/$aspec
              they might have pointers to each other
               the latter might be able to sleep
              gets complicated, see resolve $n
               eg renaming a chunk, etc
                has to cascade into pointers of it
                 can we replace certain related X/$aspec/$chunk ?
              the Leopardo@3 
               lv-ing can subselect X** rows to wake via io
                eg refresh only $chunk**
                 recycling other X** around it, in sequence
                  even itself, $chunk** going to sleep
                   < quieter than doing i?
                 cascades o /$chunk seq -> /$aspec
                  everything having an order, etc
             
             
                 if the mapping onto its output is concise enough
                 ie altering X** to re-value various /$t
                so lv-ing @2 may clue lv-ing @3
                 the latter process might pass through
                  eg change order here, rename that
           some
            something C** might have to generate it again...
             > more 'pointers to each other' to sort out when we sub-do
            
          Y&X 
           or are there A:Leopardo/suchpit out there
            that io sources rows from, "for Leopardo's main()"
            and knows if|where we i to them
       
       
       Attention
        pits define what kind of event they should be sync for
         mostly for now,
          4&syncserve() wants someone to do &elvising
          default to the latest step...
          this is an oddness, it could be farmed out...
           going on to Fishpit 3
        may realise things while wandering outside the A
         aka othering the life of A
          eg Intro sees a YApit codechange
           wanting Leopardo@2 lv-ing
             via S 2, picking up codechange on the &way in
          any next Fishpit wanted should RunGo around
           after a weird time like this (event handling)
        
        some moves we must go around Run to do
          doing an earlier Sunpit|Fishpit is impossible
          < for fun: repeating the Sunpit.S().
             same RunA? new W&GoPara?
          > to check Story before the next time, want RunStep++
       
   @is shows chunk structure
     certain bits should hilight
     as a Fishpit using its time wisely
     to respond to input
  < chunk and relate &aQ def|use
    bunch of stuff in Fish wants to reorder...
   < proto cm colouring ages of code
      ie subprojects|features streaking through
  
  < generalise the &fetch
    so it can talk on websockets
    you provide a bunch of recent versions (of ch** somewhere, etc)
     so the response may be patched against that
  
  < %Piing%encodeD avoiding R%strange
     perhaps the R%Piing goes to sleep once R%strange
      or tend not to forward anything|its-subspace downstream
       until seen to
     warn Gnome
     rollback This** state...
      cancel the GoRun?
  < our s|f|g -> Eight|Nine|Gnome keymap...
  < Nine/Fe++ spawning in order without running previous
     &twlim should put unknowns at the end?
      we also know its %%RunStep, a projectible of that in other Fe
  < This** %dis:0 the non-time
    cone adjust
  > &com hierarchising, wrapping? all brackology
     give mirage some groupages to try to make?
    > &complace spreading This** but not &Piing the same things repeatedly
       so compressing the amount of E** they all use
       creating links in Ness** etc
        which are really notch filters
         usually to the same self on another wave
         
         
     ie fork the many This** placements of a -Log
      only when %TX to that -Eight (that varies with each &complace)
       changes its identity compared to the others
        usu we would let the thing remain the same
         and sometimes it would take a whole individual %Such to capture it
        so each &complace can be a collection of drawings
         and erupt from each other...
        the act of cell-dividing on indentity increase
         swung by how we meant to grab something (i|o This**?)
          as a the pathway to find some target,
          or a specific something to separate from all other references * it
  
  < Fish.S(t,c,y), c.oo = the one to repeat on &syncserve
     the ceremony surrounding waking the A.4/*
     ie the .S becomes a way to define routines
      indifferent to use
      are sequential do(AWVT)+ until satisfied
       for an A/such ?
       hook into their life and times
       could be its A&main, or schematica
   < lvmergible
  
  < some %ttl ?
  < Fish up the I-land for a new .html
    and check it can see all me.* it needs
    pull things in via @is chunk select
   < &fetch may via @Inc 
      via @Run? read %SummerCat
       it had a writing of:W capability...
        doming thing list brack into the $W of Fishlive
       &Jproto_done ~~ Runin having its
       
   
   < ~ (&c,t,N)
      and without A&log += it
      with setting things later..?
       pretty handy. as more brack rows.
       and how to &com $another_com $t $c
        such that they nest
   
  
    for completeness of an idea there
     that the next io suite may know how to help
     
   &Xio plans
    &Xsim c.long most of the time
     &Xsimp|&Xsim: long puts only the final ..x/$n 
      whereas &Xsomp iterates each s.* as a &Xsim k:v
     perhaps c.wide can do something?
      &bracko merely unions many /$k=such/$n
       and could grep the first|smallest /$n by n%$k directly
    know slep when eg the climb + put $oft of &wantbelieve
    informing the brackology multi-column reposer
  
  < Fish.S() the Sunpit learning
     plot like lv receiving..?
    multiple A:Run per RunStep
  < running into this async when we do a real delay
    and how A:Run might know how to proceed
     and return to RunStep additionally
      not forgetting This
    then Fish.S() delivers the post-async redo|next
     then eg fetch /JsBabz/
  < &Alv being the main way to wake A.3...
    means the moment can express which parts to focus on
  < Fish js loader, from W.js
    one big legacy $me merge, then + more:
  < me as this compiler, to W.js
    then we can start using u at compile time
    to load io expr parsers
  
  
  < P|Q|O want c&pi=P|Q|O
     &AiQ to avoid making ...$oft of it
     P%O becomes Pc&b?
  < be nice to mute the complace -Eights
     for speed of dev iteration rerun loop
    if Fine/Fe/Eight%dige we could split them up, know ok on Outs
  
   we are generating lv then
    taking Q into the territory
     to Go the refresh of it
     find some way to Attention A:more
     eg @is, the ack replacement (find text, Ctrl+F)
     we would place a new Sunpit for it
      meaning a Fish.S(...) (A:least c&step) is coming
       > or some-such A:Run Step, via Go
      > priority Yinging to Go things
    bringing metadata
     for iterable sub-change sleepology
    seeing
     when The should retarget
  
  < Amess real time
     see %Cat, Run can elvis $W when more is needed
      Pro then might want to wait, rather than Run or return
    suppose 4%synco/later or 4%yls/ctime
     would e:synco|yls to @Pro
      may have a timeout | need driving
     before Cat idle enough Go to -> Gnome|Fine
    &syncopation / &complace when async...
     instatunnel a slight Run to i -Log them
      
     
  
  < once redoings possible
    Compiler seems to be using that to good effect
     puts $of=W.js (species=js)
    Loader 
     where $of=W.js
     compose $me (universal + particular mind)
      
  
  < -Difmo%skip - only show when either input mutate
      the Nine diff of -Difmo get pretty meta
     we have to load full Ness
  7C♲^3 should keep %Ctitle
  should be able to click things open forever...
   -Bet individually put-for:
    a -Lab/-Eel**
   
   < run into want of &Yinge or something, &elvisioning?
   < all A.h.o is A.h.i, .o etc are oThis
    
   &com leftovers
    <<<
    may|not let the $D into %Outlog or out onto @Yingulog
    the A^^ climb around may locate $Q while async
     < sound alarms when not expected (&com c.maybeasync)
       similar to wanting more @Run time, see &wantfour
    Gc&stac: bunch of global &complace()s
     so a completely disconnected A** can still -log
     usually until async (&Sunpit leaving)
     or Gc&stac
      which captures everything
       until async (&Sunpit leaving)
       or perhaps whatever isnt captured by A** somewhere
       or stays on
        ig Story** wakes, which are us reading the -log
        This** should look normal? stuff like that
        Ying 8 would know what is related activity
        # Story+Fish used to be more wandery like this
        # < once the layering out all the test run noise (and deltas)
     
     
    outside of scope, for there is:
    
   -Log:
   < -Log style
   < RE/-Log, may gain a RE/-brackology
      for humans to look at mostly
      subtract what -seven/-brackology can express
   < %ope them from -Eight or -seven
    < unless on an allok testrun
    < all -seven/-Log() around a Ply~ -Log
  
   < -vat should notice n:Run, see nlist
      what &Jx does, and &Superarg_arrive
       < &Names_near
   
   < &brackology compressing lots of rows per -Log
      or per -seven too, esp glowy changes
   
   < Yingupile the This** angler

Prog
  < run the numbers on 20k cases per day.
            # -Eight may fault **-six still having y&R[0]%commit
            #  ie, avoid hoisting D** that dont make it to:

  < rearrange Fish a bit... drop all Story talk?
    or go straight for new I:ball, new Inc|Pro|Run, Nine...
     it seems @Go (@Gnome) would have an Inc|Pro|Run
  < fi&elvis, or &test_Attention
    fi&com and &log...
     do handlers for that stream
      while @Run in session
       or things are Aing to it..?
     -seven/-Log
      will need to D(isplay) toggle on from -seven
      whole -Log (@4 - n** downloaded) at once
     -seven may draw &brackology
      also D(isplay) toggle|do-at-all
      leading to /-six
    async message arrivals
     wake @Pro about it
     which should remember the S was wanting
    
    < for a looser Nine that slurps logs
      ignoring what isnt around our stuff
    # lack of ref observation (Eref)
    #  put this on the backburner for a year
    now...
  
  < fix @Gnome sporadically not auto-starting
  < and hanging at %%pur:next:$S after Push
  < @Gnome while Fish is async
     waits for the higher S of:
  < @Run/@J:Fish
      which has emerged from @Pro S, %%Go-ing of Travel|Story/$t
  < Sunpit must realise it wants to be about something
     ie using S to fill in time
    if not already
  
  < test basic X**
    would want to stitch up Lines, push only ~
     in prep for new Nine<->Eight**
    also hold A** at various ov for &voice
  < adapt w:Fish attentioner? sync dispatch?
  
  < get Thingo, the compile server, going... Gump involved?
    kind of two laptop territory, the way this machine has been acting
    redoing Display and the Planet (walled garden of sync)
     with a new A!
      so we can Display any time if Eight** seek
      and stop the overall memory leak problem
       which can limit runtimes to 10 minutes when interactey
     
     ghost is worked on, way is worked with
      ~~ n made, u using
       ie perl loads chunks of other code with use
  < Try@3 armap()
  < Try@7 Inc wants @Inc time
    < Inc probably has recv.wait,
       return 0 causes wait (usu?)
      later steps wont happen?
       and Go from them pause?
        this commits X
    < Inc may have &Superlater
       for wanting a new time of something
       once a such-a-time has been merged
  <<<
   preface:
    train:Search:
     - Ask
     - Search: oft wire -> Q
     - Have: per group of Ask (Aip to &t), e:elIntro ->
   Try@7 now:
    train:elIntro:
     - elIntro: having each Q
     - Inc: loaded into "here"
     <<<
     - Pro, or %%mot RunStep
   to version inputs wanting Inc++
   
      
   
   tempting to run off to proto:
    @Inc - oft server asyncery
     harness wire protocols
    @Pro - we %%Go the @Cat for @2
     which means this thing prepares a Run
    @Run - do A.4 A:n
     getting into &Piing somewhere within...
     we have a %ball** to ride in on
  
  -brackology
   would two-column this %%sustain business
    based on Eref leading back and names matching
   trying to layout like 'resolve $n' against itself
    and diff from the last -six
   focus %%Incsum across many -six
    Abodo Display mod
   two orders of magnitude better visuals!
   
   
    to prototype &sustrain elIntro already,
     a.c|sc are? it is ax-ish
     wants to use &sustain in there as intelligently as it might y (gs)
      exact location of Sunpit-istry can move around as people refer to it
  
  < num|numb (num|isnu) for loose|tight number type check (and -Num|-Numb)
  < seeing every change from the day before in high speed would be great for morning stim
   RiceTrain doc
     we have sus:Cooked_i <- sus:Pot
      v.a == was == g.wasa.a == {of:ri} ($gs in Pot)
      notice that:
       v=$a = &sustain Pot:$gs
       if (for Pot) $v=$gs was new every time,
        we could hakd(v,was) easily
       else we mem what it was #format
        as in watching a hash change over time
         we might remember some D** it goes to #adhoc
       if (for Cooked_i) $v=$a=sus:Pot
        simply follow el2 etc, ie $v == g.wasa.a
         perhaps settling it down to el3 etc
        or whatever it does #format
    
   < %%dome=DX: combine rec|su[pt]e|dome?
     be what brackology sorts and mainly groups by
      each DX an array of idX with gk:v or s
       array like an Aip with idX instead of num
       
      could articulate a complete &sustain s (and sute pointer, etc)
      surfable X, would have the same vague-idc-for-inclusiveness
       as eg $n from &jaa might have more n%* than &jaa s
       < vague idc for vague $car
        < -brackios putting all this layout together
          clickable brackology, with &sustain|format knowing
   
   < @Ply putting one map of the world over another
      eg forest area by climatic domain https://www.fao.org/forest-resources-assessment/2020/en/
       on the google maps drifter
        the garden of spacecoms suite of live screensavers
        
    #  < can see Ec&b sometimes
    #    interestingly not covered by &forgetRunStep
    #     picture more E** to figure out
    
  <<<
  # longing for not-sus work, yet...
  getting back to &sustrain,
   which will grow %%Go
   the $a is the perfect thing to have while async
    committing brack while async would be nice too...
  show pull
  
  < make it harder to write haks(ers) when you mean hak(ers)
  < &Locio some Travel/$t other than Try,
    start bulking out the &Xio around oftserve
  < the state within those shuntings can be hard to grasp
  
  < -brack should mirage reorder largeness on its own line
  < -brackios mirage for boxlink:
     the drop:rec -> new alignment|tractogram
     two columns
      and Ply from last time, angle
       esp $a dis?continuity between times
     doing Eref self in the more recent place?
      or Ply would negate most of it anyway
  
  < A:Fish gets A:ws, etc etc...
     for ws:digwaypoll, ws:proc/$pid|$cmd
    X/...$oft/$believe... can sus:elIntro
     
    @Gnome %%Go -> @Pro
     lets the async Fish @Run++
      and @Pro|@Inc++, within timelimit (or %TX stop)
     lock &elvis to Ying meanwhile
      same for @Run when the Go is done
      though some got-todo signal may @Pro any time
       eg downloads ready, manifest in @Pro
        and @Gnome may let it happen
    
  < time!
  < @is!
  < @Ferg: scrape fergus-art.space, has .swf links
  
  types of &Sunpit:
   S o on/:ward/:ness
    one place to start receiving them all
    # new idea on group by:
    group by ays&ward if there is an inner:
    S o $ward/:ness
     this having each $ness
     not another query, io should merely iterate the sub-result
    then here again
     so the many get subtracted by substructures
    only per|for $ward with some /:ness
   &supetime
    doming each supe/sute
    they could wake looser
   &sustain $k/s.*/c.*
    these groupings are doming
   &sustrain $t | $k/s.*/c.*
    also
   
   it is full of spaces for &tt | &elvis | &Effect to address
    
   < making a clean break to the next thing w:Fish uses
    w:Sunpit
     &Supetime
     &Sustain etc
    sub, fork for experimentation
    serious arg parsing,
     Babz for multiline &calls is soonish...
    
  < @Gnome pick up %strange
  < @Gnome be a little more attendant when Run++...
  
  < Try@6 RiceTrain sustained something
     go el8?
  
  < &rowcap: requiring a.done for everything?
    wants to impose basic listality on whatever its looking at
  < speedier CodeClick seek
     multiple levels of? might be annoying
  < @Gnome talking to foreground and background test runnings
    having the background in a worker, in your flats computers
  < @Gnome making %%Go that -Effect to @Cat
     and of course, merge the %SummerCat variety...
      %SC basically has its own Ying_8
       with Run|Pro|Inc being busy until done
      you then consider all the Outlog as its trail of activity
       might be a lot of E-six to do
        perhaps -seven can unify a whole lot of them?
         the @six-log
      should work in This... perhaps some of the -seven want to unify the whole lot of them
  < rebuild A:Fish ... Do|Be
    with -pipe, &t, &way, &Sunpit, &Piing
  < E Aip should be a huge speed boost
     sympathetic to Rcrux
     Eref needs to Xperc
   # also doing too much G&c can really slow you down (jQuery html manip)
  
   
  <<<
   < 'a' in Codemap should seek that <<<
   bring up banjhead for tunerplans
    burn holes through then grind the finish?
   < &tt, Name want to fit down to the T.sute
     know how to solo the $n//$supe/$sute
      ie wake R subsystems
  
  test &sustrain
   
    puzzles to story:
     < for simplifying the line of the trail of attention at things
        making legs that go look at some related part
       Codon doesnt do much of this, only min move distance or so
        would be nice to have the latest 3-5 names vertically in x=0-1em
         edges + corners of the screen are most easily pointed at
       &sustain packing into each other over time and space
     < @is:
       match contextualising
       diff remembering where
        < rename diff voff, for any type
          eg if we want 6 pics and have 4, we need 2 more
           is secretly maths
       committing changes to the diffs
       diff Lines then diff D,modulat etc
        even E if it can be got on a branch (G it)
       animatability
       sort by match quality
        eg $s\b > $s\w, def > use, etc
       makes an ope-map for:
     < Codo all cm input A:e->&sustain, regrouping fast
       leaving a trail of what is in minute increments
        patch makes link to things
     < nearby: scrapbooking
       eg go through all the wiki/Programming_paradigm
        as eg https://en.m.wikipedia.org/wiki/Intentional_programming
        googling images|video for visuals
         get yt thumbs, find way into
        in two hours
        makes a thing about it
    eventually:
     < show changing text rippling through alterations
       mostly about ticking over expressively
     < find movin chunks in a diff
     < the finding of anything as a subjective possibility,
        that adversarial forces act on
         eg the ways to recover from patchfail
          the logic of which become addressible
          through its syncing %%sustain
  
  turning A:Display mode around
   fast clothes change via modulat class 
    hides all A.3-2 stuff besides its %Ctitle (old equivalent: &domesticate)
    the entire tendril or each node could click on again
    a school of bead chains
  
  RunStep
   is the frontend to a progressorator, see &Sunpit
   it might hoist %Fe in limited expression, for its array of ok
    they should be able to unfold here or there (where from, %Fe^^^)
   
  
 <<<
  
  < Nat
   < project weekends
   < shuggle
   
  < A:Fish grows:
    the $me that /wjs/ constructs should be clonable
     $newme = ex({},me) may work?
      or they might all capture $me, so everyone must:
     then NewMeFuncs_2948973548...(newme)
      but only if they expect to replace or be called from things in earlier me.*
      we could do some invasive &sustain $v=me
       where the original mes get the newme mixed into them
       but we remember what their original .* was when we mix it into newme
    Aref (replaces Eref)
    @is
     The|This used for searching code
     
    -The
     Aip-local elvising to|by itself
      sprawling open stuff should align somewhere else
       eg what Eref did target find (and what could it find now)
  < search.pl - another Mojo ws to `ack 'pattern'`
    can it build from W:is, the same thing that runs output?
    @is searches ghost, follows code around
  < serve.pl
     /proc/
      to get ws connections pipe to perl6
     /blob/
      GET|PUT unreliably (ie ipfs)
      to give perl6 its code + data (grammar + source)
      
  < e:R doesnt always RUN! have to watch #msgs
  < Ply unrecoverable should try again once
   < having Yingu on who is projecting what for the keys etc
  < asciichunder
  < Fish A:Inc|A:Pro|A:Run test
   < &TXin destroys its args?
   < -Bet future
     may have to climb downs to it again
      it is probably still receiving us, etc
  <<<
  < get back to Kali d
    put windows ext driver on usb partition
  < encrypt Photo
  < fun grinding
  trying to spend half the time on:
   * test
  < Try@3 js trivia / sub 
 
 randoms:
  < @Nine Accept|Fail
     with -The pointing to things it wants to ref match
  < @Gnome wants a little REPL
  < @Gnome pur:some stops e:R working
     since relying on calm to RunningStep
      and because of a %strange
  < R'Peace'%strange diag, nodepile? must be okd?
  < all OK from refresh
     waits around to begin, presented with elIntro el:2
  < opediff the %string-wobs
    -brackio** seems a good subset to proto the D-structurism
  < &SuperNine bunch the %inline
  < e:n to Fe%%mergey
  < auto Re:Try push as soon as... cursor leaves Nine?
  < auto Re:Try push OK -> reself, wake @Gnome
     it could also just realise the pull is the push
     < what else happens when: x.ro('Leave') and c.pull = 1
  < @Gnome could do with timed visits while shuntables
  < @Gnome not accepting elIntro until step 1 is done
     and mapping dependencies anyway
      by wandering steps out of order, binary search
  < how to keep a flock of gits branching at each /**
    such that a Codon keeps its wip mutations like breadcrumb nav
     even while it|parent is at some other branch
   
  < test &sustrain
    with its own Doming brack
     which for some reason has been the exclusive domain of Ying?
    eye to Aip
    which allows us to point to whole things of time
     or merge new thing from bunch of pieces of time
    eye to &is, text searcher
    
  < &Sunpit: S as X
      has brack index to done, found
     has some next &supetime
      grows intention to visit certain S, etc.
      the way can then serve requests|iterators via any S
     should know if you break|return
      not while (&S,...) again after
      hooking into &way packdown()
     dream:
      S for stylehouse, $ for terminal
       S,S-bar gag, be careful if you see this you could totally mess up your whole system. its terminal.
  < Text having Fish-compat diffPs, etc...
      notice moves
     one &accept may help others
     the boundary
     push|pull something that %%oust and %%inst
     eventually
     > map C into string with the grammar
        or just see C.t, etc
       so we might subtract personal info from it
        even once it is entangled in non-repeatable computation
  
  <<<
    < %Abodo.any_point
       flashing the border-color
         may add 0.3 width border, pa-=0.3 compensates without reflow?
       overlaying a big _ for 0.3s
       just pointing if on screen
    < %Abodo.tour awareness through this set of things to look at
      set of mergey -six
      lines /matched/
  e:Q pause all %%Go (RunStep)
  nodepile is somewhere
   @Gnome: Ninec&w means RunStep mode
  
   < test expets(), Index f etc
  < @Intro where P%error
  < &mirage: help node modulat break after brackology, before &Piing
     not as easy as inserting space:\u0020, zero-width-space:\u200b
      or the soft-hyphen:\u00ad
    wants mirage to group an ideal set of lines together
     as %dis=2 (inline-box), apparently
   
     
  <<<
  < delta and Aip observations in or out of A:RunStep
     makes data that only comes across in vectors?
     see Try@3 / js trivia / speed
    and while This** percolating
     check those %%oust-almosts for re-insiding
     should all %onlyish?
    &Piing control, for run-once
     or just %%oust that doesnt rewake it
     will save run twice time
     # near &Piing control:
      pipe in D** to compare modulat etc
        < ende - the symmetrical encode|decode thingkitexture
  
  @Intro 
      < @Intro lock %Paving while @Gnome active? could be easily done.
      < Fish will make Q+P perfectly
       < they all share, whether -Effect or &elvis getting them around
       < Gump could &diffPs if /blob/$dige always had it
       < split part of &diffPs that sequentials Q|P strings
          it needs to see the first == of it
          and move the w:Try getting somewhere... re Ninec&w
       < while elIntro:w:Try, elIntro:w:The may opt into retrying the steps
        < passing info about which Introtiv,... matched it
  
   # < modulate marker of where this emerged
   < after a long dl, -hat is compelled to go way over the nl
      to get back?
  < -hat data immediately # needs Yingulog inspection
     wants to grab that bit of tape, pause everything but S:Thyer
     might have something to do with:
     
  < Y:Easy - a reflection of R:Pi_The
     started by cloning in some accepted R**%*
     and adding R**c&* to compute %%inst|%%oust
     can work on %%sustain?
      so could they leave handlers for us...
  < Y:Ying|Steps|Schema via &sustrain
    are too small, get confused.
     mostly just ex()
  < idle conjecture: R'SCones's W/*%SC=ThyThee
     is used to engage a W/* template and behaviours (Ying%ThyThee)
      modes of consciousness besides %ball in Ying
    might be better expressed as
     W-someYingPi
      a way for the mind to know the life of W/*
       or maybe its all voicy
      would be applying a Y:Schema like %ThyThee
     
  el:
  el=5
   Soogle see &lvhashave for el=5|6 pairs switching places...
   Fish see 'it could be stated as an emptiness (el:5?)'
  el=6
   < quite a few schemes out
     build Find
      a 'el..?.?.?.?6' 
     usu 'elIntro' would search first for '\belIntro\b'
      then see the &elIntro, focus on them
      or loosen
      let open a bracket
  
  polish elIntro
   generalise to &elIntro?
   configured with this S-finder, etc
   relaxes when it gets an OK
   < &iot and &Sharg sound
  test time
   actc&times|vators
  test Fish too
   it can &t without throw?
   %SummerCat was how different?
  perl6
   runs first, forks serve.pl
   or via /chat/ ws
  
  making lv from a &yio-like interface...
        # < wants to accept anything from anywhere
  
  @Gnome
   detectables:
    changing results while %%oust-ing
     capture every -seven version, not just at &EsyncThis
     the very first one is most proper
      should have got data mapped in before h.hat() etc returns
       is seeing|copying data in again later
       This/*/*/* seem to wake twice the first Run,
        once thence (going on R%icount)
     sync first thing version (of the reRun)
     then sync latest thing version,
      into a subNess
       which can probably be disregarded as ood
        < resuming Pii@3- with the mapped data only
     auto ReStep
      could just make it OK, if it thence wakes once
    as soon as Fe has R%exp but not ready+ok
     could will a quick retry (while W:Ness loads)
      possible ~This from retry would be presented as such...
       tags along the branch coming in
    accept+push, Fe Ins then ==, but doesnt ready|ok
     auto reself, gets rid of the pusher
      TheF already knows when news is a push
    RunStep 7%dodge !Fe are likely el:2
     auto -pipe the $W:newNess sooner
    reRuns, going %dodge (and going back again)
     # macroscopic 'changing results while %%oust-ing'
     #  may get more meaning when changing behaviour leads further astray, then back
     will sprout a newNess # not since 5f4c0c2b3265f4418
      see which oldNess it is like
       going OK again, only Ness.t changes?
        would be a little sidetrack coming back
         should know what caused the pend-up
          which occurs in exactly the place new Ness do, of course
         knowing if the next Ness is arriving
          or its just more said time, mumbling on and on
          so Ness/$seven captures thing right?
    -Effect ope changing results, taking ages, looping
      looping may be from non-determinite R'The'
       or from looking at something that changes
        eg -Fez This** endlessly accumulating itself
    
  nextweek
   adjust E for diff injection
    ie replay from what can be reconstituted (D**)
     a non-trivial s->D->modulat?
      &thingo will be hard.
      others maybe not? %Ctitle
  nextweek
   xdotool mousemove 20 300
    adjusting cv, laying out typeups
    
   test running is for dreaming up notes
   provide a predictable schedule of?
    should coincide with becoming sure|not of some ~
   < @Ply dives E** that limit out, gets lost: Try@1: 745179654bd434fb6d
  
 <<< Sing tool accumulates callabilities
  
  &Supe* catch? Run catch?
  S .leave() etc, dome on the inside
  search server. postmessage, inter-focus?
   that awk fork that shows heading lines
  or just:
  forward escape, Fish &t unit tests with a little @Inc-fakery
   Wud ws:chat/Sea
  perl6
   grammar for io expr
    match sub-grammar to an io proto frontend
   might give better compile errors
    to know the token at <anonymous>:1:12
   stylehouse.git is now half the size of perl6.deb
  see # < &sustain one (bunch), til they nine%Is
  
  @Gnome sooner
   no async w:Try...
   send Cat Story
    see Doming & Beeping will separate
     Do can Go
      Beep lots .done()
     gs: guess, gets .done()
      gs.* can identify, clue how it should be elsewhere
      the %%sustain=gs type
       the marks on it smeared around, usu isoft()
      the %sustain,RunStep .drop() perc back to %sustain,elIntro
   
   < isoft(s) returns oft-ish s.* (t,of,dige,version,time,args,...)
      fi&Qbel are version|src
      < read
      Fish avoids having to define the base set of them
       by having oft-ish in $s, the &Qbel-ish in $c
        ie front asks t,of,args
         back knows dige,version,time...
     
   reset if @Cat awol
   show -Womb?
   prog
    say current step (mw:10), diffsum
     place to put buttons
    Run++ button
     should push through when everythings changing slightly
  time
   as multiples of periodic events
    and how would you know?
     observations hang on A
   https://youtu.be/8IWDAqodDas?t=565
    is entrained, mostly to light eg going around the sun
     or activity or food
    circadian rhythm:
     every cell has a 24hr cycle
     keeps matched (while timetravel|redoAip?)
    the ability to perceive time accurately
     eg count off 2 minutes
     decreases when not in sync with outside time
     is important for performing tasks good
    ultradian rhythm:
     focus in 90 minutes or less
     then focus chemical exuuding tapers off
     < subdivide all these todo-lessthans
       into 90 minute testables
    
    doctors must spend a lot of expensive time on stupid outcomes
    
     
    
     
   also, subtimes, may allow fugues such as:
  @Cat/* is a ready before any more space (see &settle)
   how exactly? would be refactored. is pre-&nodei,
   
   &SuperStory in parallel
    @Gnome managing the @Cat
     interface to Run, knows Fe
     # %PiiCat|%SummerCat
    @Story just
    through the spirit gateway from @Gnome running a @Cat
    signs Fe + Nine that tested ok
    the spot where state is manager
     taking a settled @Gnome as current instance
      spooling the leavables beyond one trip through the Story
    Run++ instruction (being a way-doing test)
     should be noted somewhere? Ninec&way?
      perhaps the first -Lab loads the way
   
    audit y&ers
   brackstract: reinflate some more Eight** in place of @Lab
   some more, lv-ish leading up to:
   brackstream: node pile over time
   rename Textl Te
   
   A.c.Srupto, so S openEight (see Jay Srupto)
   A:n hook for n thing -hat $s:data
    < Babz sometimes: n any stuff => any expr
    is creating This**
  
  @Gnome later
    < &Sarg behind io
     < io even, redo the old iooia etc tests
   %Names|&Superarg here|there
   %%Go seems to want to carry ov to do
   %%hire for @Run start unless -Lab coming
   -hat should know -String|-Num|-Number, -bool
   read some %Story anyway
    rename Jproto Pro etc?
   
  
  
  @Yingu really, expr
   can ++$This mean a new $This
    and $This++ mean a time inside it
    thus invalidating its own mnemonic history: ++i|i++
     is adding to i before|after we have it
      ie new $This via el<3, or ~ via el>=3
   @Yingu/ clicks go to Yingu-Lab state
    to cast npile in time, adjust exp
    or:
  dump
   async data looking
   involve -Lab for their source, eg @Yingu, @This, etc
    eat:
      &Saturn ro Sat does a &Piing before its above, RE:Run has y&ers?
       just wants to dump data, &pic?
    
  
  today besides:
       banjo
       stereocompsort
       nab Asparagaceae stem
       kawasaki
       datacabling # moot
        ping wired:
         8.8.8.8:
          129151/129389 packets, 0% loss, min/avg/ewma/max = 49.265/62.474/57.669/420.242 ms
          < ping wrapper for '0.1839% loss' (to a millionth?)
         gw:
          142842/142880 packets, 0% loss, min/avg/ewma/max = 0.203/0.510/0.358/48.850 ms
           is 0.0266%
        ping wireless UniFone 2, after new+repositioned AP
          65244/65342 packets, 0% loss, min/avg/ewma/max = 49.899/77.827/66.212/5832.150 ms
   

  idolity:
      <<<
      read Superdef, &active, %%Go making Gump/*
      or simply &indot a pile with %Name inc while %Yinglog
      while %Yinglog
       consecutive -log looking same other "x2" to whole
  
  overall
   < generating lots of sub variations. [szjd]aa?m?
   < theone( &oXn,X,'who' ) == &oXn1,X,'who'
      may fatal if many
       or find a sort expr overhead about it
         that might suggest which one
          eg [-1], %current, %Into
      &oXn2 might resolve $n
       to iterate the /$n with another iteration overhead
    < overhead:
       via T.* appliances, %TX suggestions
         esp those related to given X, via Xip
   < Xip, Aip, how they do.
     needs emit
     leaving holes in space, knowing time++ per light cone
        #  the Aip heartbeat sequence sorter
        #   also percolates changes to args
   < Babz [-1]
  
  phil points
    # RX flex
    passing c.stickline down to &Qdiff, R%Zif, &textdiffN
    < as a %TX to a certain function call
      could swap out A.3.i.* to one that arrives the hook
       one of several ways for The** to arrive in This**
      be a dim The thing, as are any ope=0-ish edges
      and inject the c in args
    nearby:
     &tt - buttons and other otherables
      < isolated modulat redo 
         hotwire Display for a non-top?
        see Fish &Aredo
         which deals with $Q change percolating over olds,
          decoders for Q%of:The (%TX) exist
     eg volume|speed slider
      has some "optimum" level indicated,
       that if clicked on resets to there
    
    # E** other, cluster highlevel
    #  it is in this two-legged shape
    Y:Easy %O** for (s|E)**
     the way we &Sarg...&Saturn**
      stretching rowing into a hole
     other can be inflated each time
      eg to compute who is active, %%oust what etc
      re-E completely when its input changes
       ie event horizons, eg the %%active community
       you arrive with an osc-like ~ awareness
        eg we are entering Go@4 
          after another Go@3 is the latest %%active
         the benign region after the peak of its wave
          its The... tendrils may shrink slightly
          and vanish once Go@9
           which retains knowledge of it having happened
        transactioning X accordingly
         which requires a generic el:9 for anything it might have started
          probably visiting s|E** to realise the ~ there
          but it may be an eg &tt setup that can:
         some of our output might be othered
          do it all as a batch in %Yingu
           which always happens @8
            so it can decide to wake %Yingupile** etc
        or usually just
     
     cluster-wide high-frequency doppelgangers
     otherable roles of (s|E)
       %%oust to somewhere
     high speed, multi user (whoever &Sarn etc)
      which makes all the stateful %%active realisings,
       %%oust, desire|change of %Name etc...
     for all the @Things (nodes) and &Piing (Ec&uber)
      defining a nodelist:
    
    %Yingupile 
     otherable from anything Y:Easy is on, see above
     &indot-like:
      creating permanent Y:Easy%O**, eg for a node
       from only looked-at s** that uses eg &active
      scheduling %Yingupile/ItsStep for selfing
     is in charge of:
      sessions of ...
       eg:
        scrolling viewport with mini-diffs
         ie positioning maps of *
      &Gnome_want_quiet_wake
       with its otherable sensitivity
       
    # This<->That 
    mergent E** 
      or any irregularities in the play
       eg %Fe needing reiteration|more time
        time|Aip++ can be folded out in &Ply,
         like an acceptable lie, just to see out the test run
          and makes the Story non-canonical
           due residue left in some @Lab, see below:
     are an open
      impetus context-showing, highlighting
       that is join-with-others
     should be %%oust-ed to @Lab (may el:2)
      we must &FishElvis intro the E** selection
       as they remain since Diff memos
      zombifying pointers should refresh the %Fe, Diff, etc,
       though it should have happened anyway
      and give @Run a coherent tree,
       this bunch of diff merges with other stuff (and older itself)
       but keeps the origin of its intent (Fine/%Fe &mergent)
     then Y:Easy @Run can otherably do all that open
      may do -Effect ope, &diag, &textarrow, highlighting, etc
    
  
   
   < -String want to conjoin across C** (ology)
  
  @Ply
   < diag better, unfoldables, options on it all
     as a -Ply, -Bat could do things
      inc the general folding|scrolling to E** wanted
   < send to E**, to place markers otherably?
     scrolling diff+source on screen at once might be easier
     < can it tunnel the tips
       and RX qua.recipe, non-encoding
    
   < only need til -six
    < hilight regions... mirage-like superset anything
      the bunch of ⦄m want Yinguspace into @2 style folds ...
      mark ~E (or between 2 E) with a burning arrow
       '++' simply for whole line?
       otherwise copy Comp modulat
       
   
  < which -seven/-six from that
    scroll the @Fe and @This together
   < Yinguspace pulling associated things into view
      lots of viewporting to things to be open
      @Cat-ward of the open becomes openable stem
  
  < &Effect %%inst
  < notice if they arent received by an -Effected?
  
  < sending something over there to look at (throw -Fez)
   < sending you over there to see stuff? modes C
   brackstract:
    < seeing R as node
     open %%e a bit?
     
   < streaming new log $node -> pile
     checking &upfrom|&downfrom morish (modulat is completely downward)
  
  < ! audit use of .split(',',2) to mean '3,3,3' -> '3','3,3'
  < %Ctitle for t=''
 <<<
  'X versioning of'
   &indot adapted to eat U...$node pile brackstracted from %Yingulog
   # the Y is the A.3?
   #  Y, Yiu, Yiul, Yiup (Ying, Yingu, log will, pile progress)
   you never select an A, so A means all A
   
   a Story should have numbered -Lab
    which fractionise for a spell giving non-sequential growth
   and named scenes of time Eight** scalar-ousted
   
   %Yingulog (not %ulog, its test|proto)
    shall R%boost to become brackstractions
  
 <<<
 
 Phys:
  digita
    < arrange like fish, mount in shelf, make swim animatronic?
     < print all other code containing '=' like a magnetic field around it
       sorted by position relative to equals
     < deconstruct lcds for transparency?
   < hibernate lock crypt?
  musico
   banjo headplanks smoothening
   need to examine grinding for finish again
    cooking oil?
 
  tanned objects
  remembering remembering
  you*ve got to remember your dream
  there's A or there's falling down


  thought dispatching via &elvis
   because we want to deliver an -Effect
    which dont always need to come from somewhere
     ie self receives the tail end of thought (loop ^^^)
   some things would
    S thought would
     #slowly changes font
      # morphing vectors into each other must be somewhere by now
     report
      # some of which can alter the dimensionality of everything
       # what you have in front of you there is a die
   ascii castles, holding embedded y&thing as Lines
    eg ipfs for $id, get something else (itself) othering $id thing
     pulling the castle off, the $id thing is complete
 g

  < phil reconcile &Superdef     
  < place for parsing out each|map expressions
   < Fish w will be C
    < really need to lv, diffs apply
  "if you wish you had this before"
  
  ^ immediately above, or else
  ^^ any ways up, til 4 (you must link to stuff in 5)
  ^^^ any ways up, all until not
   .it and .til, one = .it[0]
  
  
  < &tt coop %Yingupile foreign affair
   < it would say about the ope:0 for seven/*
  < &tt 'show:D' saying 'D' in a bubble
  < &tt int The
  <<<
  mind lookings over time
   push|pull currently clobbery on %Code
    should &oft_notify
  seeing time is import to inteligise Nine to itself
   aS is lv
    also to get a sense of what elvis is doing...
     %Yingvoids into %Yingulog
  
  &Shx from R.y.up.y.up.sc.z.map(n=>n.sc.z && n.sc.z.filter(n=>n.sc.Gnome))
  
  <<
  %Yingupile
   piles up $s/*/* or more, and any @Names
    as seen by %Yingulog
   usu jump to, stat @Fine etc
   %elvis to your The to adjust...
    time to minimise (x.ro 'noD')
     in such a way that etc can use it
   tell of ~ -Ness
   -Effect open -sevens
    R%Piing may %RX about how to be a @seven?
     suppose @Eight are set to a time, that they %RX to @seven?
      and also the %Yingupile, which shall dispatch -Effect them?
    or must we &Deflect, to wake there with additions, ala RBales?
  
  @SC w:TryPiWarmer?
   what %PiiCat wants to do...
    being the @Thyer/* we have so far
    with time++
    S initdata that can be reused|regen with mutation later
   wants to @Intro which S block changed, how to replay it fast...
    ie $tid++?
   with a bunch of data checkings
    to be walked through for people to learn all the is*()
   not needing to @Lab every time
    unless the @Ness/... slyly include Labiations,
    also we need a new concept of many-spheres encoding into one tree...
     supposedly W are stored into W/Such/W/Aname
   eventually lets assume any expression on a line must be true
    or return something to -Fez
  
  benchmark millions of:
   &tc, &boxcap
   Y.nodes.indexOf()
   dig()
  
  &brackstract locates and orders a smattering of s**
   hierarchising and showing @Name, odd bracks
  <<<
    say if that is not what its ^^%client knows as @Name
   and E**, beyond...
    introgress to similar -Belt
    %%oust treeing diff
    also
      -Fez could see y&up for anything it finds
       following it beyond the reach of -Cish
  reusable for Eref?
   limiting selections to <time for Eref
  
  
  
  become facets of &brackstract
   ie natural order to discuss infos
   -gate is no-time, ie RE/E are no-sort
    should share exp to the next -gate though...
  
  < Yingulog|in othering, including tiny statuses
     is what %Zaving wants. can lose track of push|pull waiting.
    pile also non-$node things like %Codon chunks
     visiting|changing swells importance
  < @Goting wants a $tid++
  < when Fish testable, make &Xsomp not autoviv
     X:brackstract_2/astract by &brackstract_out
  
  
  <<<
   research:
    Rbales, relies on having @This,
     to serve (tunnel) /** immediately
    -Effect, what can it do like Rbales
     do we wait to brackstill the lot? when?
      see 'wanting A to make visitable &S* parts'
     Thy/The - toplevel The, Run/The etc may offload to each other
       for deciding @seven shush by default (via -Effect)
        @Lab may alter that
       this should be y&Todo piped from the outsphere somewhere,
        push from E-Bat to there, &SuperGens
        
    %%active become types of %%Go,
     -Effect around?
     progress ov, so you can be the_active,
      then merely active, when others become the_active
      since @Labs stay on
       til entire time** swathe of This** is delete
     also, re W:Fingo and %%Go,
      @Gome never quit when done, is a %%Go
       and while youre there:
      @Intro -> K need to ↻?
       only visits it the first time?
   climb means up or down?
    up to white hole
  
  
  Decemb:
      < &Erefputup can say 'confuslet' a lot
      Lines protocol change:
       < put BQ at an odd indent... 1 space for keys, 3 for values
       < trim trailing \t, may have none if just .t
       < &Clone/&indo/&fiu uses el:6 for leaving dups in pz%z
      < get a code finder and tour the various 'on data' users
      # < -hat should try to spend most of its nl before dl
       # < after a long dl, -hat is compelled to go way over the nl
      # < Ying8 should lock light cones that take >5s
      &rowcap 
       streaming new brack in..?
       currently eg Run++ takes a %%pur to bring it around
       could be done now via:
        N.length or so trivial check
         you, eg &SG_RunStep, add to it on &ha (&sustain)
       or later via:
        having the source expr to redo
         or X notifies readers, etc.
        might be easy to watch several X/$k/$n
       will have to:
        have all the callbacks
         Sing tool accumulates callabilities

  
  -hat layout world:
   &Eing_some needs a ">100" limit
    each thing we dont visit still gets
     %%toomuch=limit,E
     
   Bow @66 # < should be getting %indim here and lowering
    how to opaque at C gracefully
   Bow limits are very hard
    -hat honest about showing all data
     else saying %%toomuch, %%limit, etc
    z https://unicode-table.com/en/blocks/miscellaneous-mathematical-symbols-b/
     ⦁ Z Notation Spot
     
  < Eref a blend of &Shx + chaseout
    the lack of rowing-climbing has made a lot of it ugly
    
  <<<
  < Yingu is doing self-hiering brack tiedown
   < and a toc pile... which -eight/* to show,
     + scrollTo()
     
   are going to notate nodes,
    see %Names '< when %%active, puts @Lab|@Nine for @Gnome,'
   bumping into lots of &Superarg in @Gnome
    is like &Saturn for Travel/@t/@Cat/@Run etc
     should $to via %%Control
   
  X dangler
   < test everything Yingu does:
      -gate log, a brackology with node order
      -pile of nodes and intent
      -other things wanting HUD
   < -Fez colour code /$n
    < try tabulation schemes
      to compress references
      supposedly easier in X space
   
  < &Effect the %%inst around...
    so we can wake whole tree this time
     can we always wake a node inside of us? ~compulsive %Yingu
    now takes 5 trips to perc change in + out of the 3 layers
   < -six could want -Eight/-seven in one trip
  < &Effect diff (seems visity?)
     brackstill?
     has to decide in the call to &Effect
      or do Doming_7 for them
     it can also decide the &Effect doesnt decode to any change
      eg increase not yet at some threshold
     and whether those changes can be done without a visit
      eg vanishing, css tricks
       bits of &Supe* should be otherable, wanting via &Effected
  
  <<<
  &Saturn expr++:
   &being_inst could define $sc, $mix
    or is it Rsc_mix? as in &Pii c.Rsc_mix
   $mix could be implied in i <-
   i <- should imply @n is still whatever (.c)+ o <-
    ie recognises brack forwarding
   &axsimilate(s)
    ray
   locate on path from //R^^/%Sarndat
   
   
 %Names:
  <<<
     the @Cat/*, @Run/* having their names
      @Gnome wanting @This+@The,
       the %%mayRun thing is %%Control... minisculity
        < %%Control=1|2|3...
     and @Gnome/*, synchronising with:
     the 'i @Thy/...' in %TheThy &Sarn
      pushes @Thy=s upwards
      multitudes (@Lab) usu select latest %%active, unless inside 
       time-bound, ie @The/time keeps syncing to that @Lab
        until the change is commit to another @The/time+@Lab
         time++  mutually implied
       select your nearest parents one, regardless of it being elected
        some exceptions...?
    
    which seems to have a look-above for stuff concerting this element,
     eg @Run/* should check they are that which is defined
     and it should all lead back to @Gnome for &Superarg visibility
    tying into:
  < noDisplay everything from gate-2 - gate-50
    head-down time, higher &elvis-per-second when not waiting for a &t
     exactly what waiting for the &t can de-determinise
      is a job for Story
    Display if|once no further wake? and of &Supe* etc ideal fps
  < -Fez being splurge resistant
  < -seven/*%noDisplay until awoken by &Effect bringing $exp...
     $exp must divide through -Ness/Eight/seven to get there
      time may wobble, ie Fine++ occur randomly before syncing up with Nine++
      so -seven may be captured complicatedly, having a higher Fine++
       than it will thence have
        up to -seven to notice when its .t is the source of difference
    nodes realise when parents dont have their latest y&thing
    
  on the side:
    # < elvising to a node that may not exist yet
    # < &yfuture is getting at the current version of R
    #   R|A&ip should ensure non-aborted sy&R is used
  
 &S* mania:
  &S* doing all the %twin|&Esync
    # < fix: c.arg must be in do-order for plumbing
  < conserve computing same function + values over rows
   < atomicity (or is it indempotency?)
  < Yingmind compile a bunch of &Saturn
     about where|when %%inst,listen_node|heard happens
  
  < %%inst into @The
  < %%inst** presents a hoistability:
     < -This and /-Eight amb. check all -n?
      # aka < @Run and /This(%sleeping)? should check
       seems to require hoisting a list of eg -n sleps we can other
        X-commitally
       short-term:
        construct-only is worth it to avoid complexity
         need to test update without visit first
   < wanting A to make visitable &S* parts,
      which may then resume as if they just happened
     any %%inst or %%oust spark &Piing,'-Sty'
      eg for %%inst:
      E-Sty/-inst/$i <- %%inst, brackstills them
      your -Sty etc are @333
      you then &Superinst
       taking an infinitely re-doable -Sty/-inst** with it
       to diag what its doing
        which should usu fade to 1 bit of info
         the i, that lingers after you have input something
         whereas everything else is just itself.
         < getting people to confirm delete half an hour later?
       %%inst,...
        is worked out, eg %%listen_node
         gets E%target from -inst/$i/-n
     and makes the whole bunch of inner-most eg -n
     available to semi-wakeness,
      ie any time or place
      eg when we %Piing%sleeping,
       we are directly inside or above what is waking
      eg when %%Yingu (or so) concludes
       < probably a Ying_8 thing
         to other state checkers all over
         esp those mentioning a node like -n is
     so
     we can avail this sense of what %%inst wants:
      @Ying..@Run(//-Sty)..firstaspect%%inst//-n
       which mirrors into firstaspect//-Sty/-inst/$i/-n
        in this first example of %%listen_node
       intermediate eg -Eight may adjust things
        with varying levels of -Sty modeling
         eg toggling the listen
         eg starting another page of the identity listened
          so the old page can keep lving modifications in existence
          and we get a new i /-seven when heard
        eg when time moves
       
     &Superinst for %%inst... (replaces &Piing_inst)
      otherable whims of an instance of %%inst
      callbacks that also work in other-time
       doming the bits into the same %wou
        yet with &brackstill,
         whose result can be decided to mean some-so
          usually just doing more other-time stuff,
           to run the particle to its destination
          then travel where it finally wants to witness the change:
      wakes the self if the whims change enough
       use &waits_8 sooner
        < rewrite that
        to put off eg @Run activity while we visit what needs taping
         < %TX the entire A.4, to wake up on $target
           which could be realised before even &elvising it,
            that @Run/This wants to be open
             while everything that might feed it happens
      leading neatly back to -nine
      
     &Superthing for %%oust...
      # was|is y&thing
      encodes out of time
       they climb + declare how nicely
      avoid visiting -Eight/-seven on the way to -Nine
       would want to &Csse the superdiag when unupdated
      
  < %%oust** multiplexings up to Eight etc
    test += channel ...-six html+style
    defining encoding scheme, extensibly
     path treading?
    -seven/* realise that -seven includes them
  < make &ein for sleepy dispatch from @Thy etc
       which can visit @Run/** immediately from 
        while we might -log things there
        see Rbales
       refreshing %%listen_node
        of <|> import than
         @Gnome, &EsyncThis
        as is hoisting change up to -Eight/...
         before taking that stream beyond This
  
  < etc
    <details> tags toggle contents, always show their <summary>
     how handy
     
      whims what you want to do - instruction
      enthusiasms how you want to be - realism
      
  < redo -nine
     needs easier in|out-sphere code|live visibility
      < waiting for %Yingu pile
     better grounding, see commit e4d8a712b2fd6 'back as it was, leaves a garbage'
  
  
  
  < mirage by carpentry ƾ? ⛔ 🚶 🚷
    the house is seen with a long lense
  < get serve.pl to watch sensors, fire alerts
  <<<
  
  @Run listen to Thyer**
    which we shall then Thyer/*++
   so so Thyer** streams into This:
   This** must hoist news
    ie -log should be informed of -seven using
  coming back to:
   Thy managing test playback
    Lab,Fine,Lab,Fine...?
   making X computes over there
    saving the pose (The->Thy)

  < get that unit test routine happening
    TryPiWarmer:
  < limit/ref in general
     links you can click|hover (%Abodo)
      may lead off the edge of $W**, more to @Inc
    $D, doesnt make too obvious:
    the prior art (former site of the ref)
     is other if:
      too far away (time)
      in an other Ec&pi (format)
      expr-compromised, not fully drawn out, %%toomuch
    see &Rthingo_toD 'an ~ will not appear on anything being empty'
  
 <<<
  the /thing
    o $about (someclass)
  
  test Fish funcs, generating notes
  &Shx could be from 'S i ...' while-blocks
   byo A
  
  ive is remarkably 1-9ish (1:Index, 8:The)
 
   abstracting all that
  &Sarg etc testsf
  Yingout wants to brackstill things -> /*
  similar for style island map,
   with a between wake+sleep that is sleep with Csse
    for animating node titles when active
   wants to use something under &Effect for wake+sleep logic
    without needing nodes
  
   < timing harness from Evelse
   < link all refs to the pile...
     https://www.w3schools.com/css/css3_borders.asp
  # so
  fi.had
  
  they will Abodis to move flock around
   eg whose sense of time is being cast where
  it seems a Doming versioned and intented,
   operative at A.4 to %Yingu,
   to see A&ip sprawl
   acquiring %%Go... with %%Goable
    its supervisor uplink
    prior art: @Gutago %%Goable -> @Goting
     it uses %%mot to prio jobs
     use it for setting rollout
      Super-backchannel
       flips dials there without visiting node
       entire -Lab may be 1 line displayed
     lower more urgent, %%mot=
      1
       changes in time to see
       can be implemented as dis:0 to -Eight/*
      2
       ~Run** <=> test data
       wants Nine to review them
        once a diff, triangulate diff-diff and diff
        to break apart commits to The** that alter it
      3
       Story time <=> This time
       new testrun, regen This**
        some of, from somewhere
      7
       The -> -Lab, show selection
       Story rhythms of Lab,The,This,The?,Lab?,Nine
        then we mux Lab,Ness + <> Nine/*
       
    
  < the E life should be extractable
    mock Display for one,
    commiting X for it
  < generalise &Piing noD|noR
    and structures of mute
     show all Eights, current sevens
  <
  new &Sarg for The->Thy
  
  new &Sarg for E/*/-seven//*+%noDisplay ?
   that compiles to -Bat
   doesnt affect -Piing
   < -Piing, replaces &acting, heads E/*, osc log
     small enough to show up on -Log nodes
 
  
coming around to a nice place,
   where we arrive when things are quiet
   where @Gnome paths e toward latest Thy..$n
   and|or:
   spring more Thy
   
  < controls on autoactiveness?
     for the current &Superfaff/$n
  
  < Nine%Piing xor Nine%TheFine?
  
  < getting a ~This, this doesnt seem to help
  
  < Avoiding-ThyF-return
  
  stability - safely transfer load from the outside
   to the body and vise-versa
   people dont feel the pressure from the ground
   to go off and have audacious dreams
   idea meritocracy
   there is not always a positive advance
    our inventions are wont to be pretty toys
    which distract our attention from serious things
     -Walden
   we have not generalised the phenomenon
    -Schmidt
  
  %%Go gets a @Cat
  %%Control gets /@Run/
   should have This|The now
    to <- Thy%active
   then %%mayRun allows @Run to ~ A:n
   
  
  < Superarg that arent nodes
  < eg @TheF/@Fine//@Nine
  < -Lab having stuff to permit, stream out to The
    time selection
  < much to redo about -nine?
    much confusing but ~ working
     til some unit testing
  < read %%Superarg for:
    so &EsyncThe can produce Thy before any @Cat/@Run/@This
    see # < have Thy first clue from F
 
  # < hoist more &Piering
  &acting,'Piing' should -Spheres these
   their X/$ref should be different...
    belong to This/Meta?
  Ec&top only has Rc&b
   implements a new that from there
   sharing some E** between -Nine and -nine
   keeping its first experience,
   pushing to an eph -seven when it changes
    but only from Nines perception of This
     ref-like with an existing -sevens item
    and not when you mean to push styling
  .
 <
   %Labi work things out, io @Run/The
   
   is sent from Fine, should be:
  < Fine/-nodei -> Thy,
    to then expect to Esync etc
  < break out of &Thetower
  < -Spheres implies /-hat, etc
  
  < -Bat must compile an encodable thing
    it wants to re-find the thing
     Gnome having a fast way to check such
  
  < &Effect to include 7/*
    cobbling y&thing
  < TheFine should be able to stream that,
     to commit G+W as one
  < to|from D
  < to|from D%ref...
  < conduce a Dc&pi, giving c&s an expressivity
    eg -C are Ctitle form, -n are node name
  < compress pi type trees. eg -Spheres/-hat
  < %TheTh should default other that -Bat
    the what-for system need a rejig... %twin-ish
  
  make TheFine + Thy
   Thy pumps
   waking @Gnome (eg from %%quiet)
    shall observe the state of Thy
 -Bet
  we handle ope.* at:
   &Pieri - judge light for E/e, re both E + e
   &Piero - applying it now
  <
   &Eel_term - merge event stimuli
    ie -Bet having Xsc ope=2 
    sometimes one event negates another
     usu making it never happen,
      if prior stretch of e is checked in,
       we must mean it should happen for a while...
  
  < sort light|space, apply %dim, etc
  < &Piero should %title=aq.t+qua
    and in a %dim, we %toomuch a lot
     unless matched by something else
     < might cause limb to open just to receive ope=-1
       otherable models of E waking space sense
     unless we have loads of space,
      then we could want to R inline them
    %impl should be a low-light %limit
     that stops hiding in cold light
   < &TXi to hide .t|.y.cv
   < &TXi to dim .y|c
      in a !E way, covered by %limit:dim
       such that <9 .t may show, promo to:
     yet show .c.s, anything selected
      we must &pio for|before E is real
       &pio happens a few times, for E.t+pi, then D.t+pi+v
       various aq.qua may be applied asap or @3
       eg some pointer sets Ec&pi=such before R
        or ope|dim apply @3 as it is about to recurse
        
     is a hard limit now (aq%qua.ope = +-1)
  < softer
  < consider C.*%toomuch to mean C%toomuch
     ope+1 every %Cish?
    < want to pick the best ref self...
      seems we want to add to @3 &Ereflookup scans
       to add ^^^E>/laterE that havent yet @3 &Rlimiti_ref
         < a climber lurks about &FishElvis
            $E</this means ^E/this earlier than $E
        so the refs must be at each E-surface above us
         eg R/sc/thing/int doesnt see D/sc/int yet
          since D is yet to @3
          < do we actually only need R%Top to &Eing,3 ?
        in contrast to the seek<0 (previous neighbour)
       deciding that is better by less Rc&d
        deferring as usu, %limit:ref,later
         unless you have opened this part of it...
          < can rowing winding into here portal to the ref?
      eg:
       prefer sel/D over sel/R/sc/D
        though it comes later in sel/*
         < split out the '^' from the ref line,
           ab,transform: scaleY(-1);
           stretch it more if the ref is far away
        since it has more room...
       
       on not discovering it in time to %limit:ref,later
        it has latent %limit:ref,toomuch
        the sel/R/sc/D R must diminish
         has to re-&Eing, or is it @3?
          which disconnects anything it did?
           from R%z, their E.y.R...
          TXing they matched should unignore...
        ie it doesnt like to rewind...
         but it could
   
  < redo specialfx inline|not
  
  attempting to unify lots of /%toomuch, etc
   thingo subsets parts if not as unified
    if light level is low enough
   that nothing not-schematic was in the thingo
  
  < %limit:ref ranks its candidates with brack
    
  &Rthingo actuates magic word display,
   < eat a format %limit:ref ranks its candidates with
   < sprout brackology when %ope
     be an intelligible %TX point inside R
     
   < compresses|extends brackology
   < the pointers should work,
     adjust their syntax
  <
    could have lots of %%qualified,n=C then
   
  squish-factoring:
   y-hat@3 noticing /*%toomuch endeavours to shrink
    by slicing modulats, notching the grounds
    tiny:
     the /* only t, maybe sym, maybe ref sym
      as modulat limiting to cv<13 or so
     they are able to be clicked 
     clicking y will up to small:
    small:
     show t len<7, sym+s <9
    we can arrange all C t under one big sym
     and all that =1 etc similar
    and put in tables so things line up
     they have to be assigned to rows
      if such a process exists
  
  < packing all that modulated info so far into %D,
    actually modulating it in @6
    and a mode to jump right there if given $D** to $E** by
    and/or compare with reals we still have,
     possibly favouring the first look we got (in-time)
  < -Bat/-Bet compile and merge to Xc+qua paths
     the -Bet sublating into -Eel somewhere,
      probably disappearing over Accept
       how you save|load might be more -Bet+ or -Eel**
    show R etc from original e:click
     and follow as it updates (or not)
  
  Overall
   This activity -> The/co
    co might be a -Nine of suction
    or elvising (-Bat)
     either of which may be within a -Nine
   The/-Nine+
    may be nested|created any time
     whole area is &Acceptable - makes io-sphere:
      storing compressed instructions outside
       enough to run the tests
      and fuller explanations inside
       which diges so we know we unpacked instructions ok
   R%Pier=$pi
    is a base type 
    the layers of C-sphere:
    %E - instruction
     usu built from above, may inc schematica
     may include a predefined %D to rehydrate
    %D - description
    %C - presentation
    a pair, determinate:
     %D compressed fact of the matters
     ->
     %C decompressed presentation of same
    usu
     reality->%D->%C
    we might have three pairs:
     diff %D->%C between:
      a reality->%D->%C
      expected %D->%C
     to show difference with style
   %%limit
    reasons to shape branches
    soft (%ope) and hard (Rc&nl)
    go into schematica
     eg isC want those y,c,sc things
      we might reveal the sc first in a squish
       ie brackology
     collab with $E^* (siblings) for alignment, table?
     'stuff in A.* may also be in A.y'
      as a better elsewhere
      schematic t,y,c,sc folds other A.* into y.*
    may lead to:
   %%toomuch
    compromised expression (squish)
    may go as far as rc&not, not computing or displaying anything
     so R (&Eing it) gets a %limit=not
   &Eref
    to point to an earlier view of it
    whether to
     refer to earlier only
     check and draw patch
     or completely redraw it
    %D gets ref talk
     can be implied for -n-things
      which is itself a kind of ref talk
     D.t is R.t is $At... as it is known outside
      Dc&s may be|include C.t if -C|-n
   %D
    -C imply
    having stops (where R%D/r%D)
   %wou
    should appear as inspected
   %TheTh+ and -Bat
    wants a queue of e being classified
    reversibility generated into Th+1
    autopush unless e in -Bat itself adjusted
     unless simple
    
  
  so %make%_hat
   renders %D from $s
   or maybe it is given
  then %draw%_hat
   renders %C from %D
  or %diff%_hat
   has %E/(got|exp) to intersplice
    which %RX as %E does?
  
  inners wind up in time for overs to size them a bit
  %D should be a single C, per %E**
   may include %D from %E/** not drawn for space
    %D knows when %limit ends its expression
    things changing beneath the drawn resolution
     but within the scan+remember resolution
   
   making domes for an osc to sitch & stitch
    can do as self|other...
     the put into -Nine an other
      may occur after the instant
       as in adding compressions
        that will be there next time
       with D onward
   everything gets a weight
    &Mwix all @67 so we can measure box sizes
     caring about 3,6,12,24,+ characters
   
   limit
    if large or already expressed:
   ref as lv
    must be X sewing together around J
    trust previous look-in up to some point (-log time)
    restate entire if diff storage...
   @2 classifies and extracts id to $D
   @6 renders modulat for (thawed?) $D
  -Spheres
   examines the others in a given -hat**
   climbing|neighbouring 
   C-surfer (yup and sz)
    that yfutures
  Bat persistence model
   nec bits sublate
   writes a D** it can outload
  The solves e,
   This refreshes minimally
  
  
  make E%RX about it
   /ignore/ for one-timers
    other limits?
  apply styles
  
  @Gome/The <-> @Run/The ?
  
  anyway, about here is half way!
  touring the onlook
  compressions as advised of form
  hanging up unnormality
  various the sideplots

  < &pio-centric piology modulata
    -seven R%elvis=me.Hook to re boostify
    as a state patch (lv) to namify into Ting
  
  < This/Ting, on top of all &pio
    per time it changes
    what Ting are new|gone|diff to -Eight
    when to restart the Story
     restart to get in-time looks at -vat expansion
  
  < generates something for someone
    ie Story/Fish/Travel
  < whether we el2 on Intro, click, etc...
    the scattered control pi of Story
    
    
  < -row** working an X field:
    generating its what-is, in eg -log@2
    
  < recording devices (see 'Leave' resets)
  
  < cm indent staircase, smooth exits
    same thing that This/Eight/... seeketh
     plugging new|gone|diff
     
   < w:Dome doesnt reload?
   < me&fiu,Z,n.t,2 is non-fatal because n.t isnt an object?
     wants it to be undefined until now?
   < &acting go show s via %Cit, all-rounder
  
  < u|Swim should support:
     chaining (modules which depend upon other modules)
     nesting (modules defined within other modules)
    both Outs %W,how_to_inc
  < Array.every|some()
  
 we
  want -ology from -vat
  
  < all active -seven+ <- -log as an instant
     and other things, to discover why:
    # < ! put one line further down and it doesnt work
  
  < data dumps the same iteratively, esp nodei
  < all Story/Fish** can refer to objects,
     host them in a Story/Fish/Things or Thing
      and try to match that string anywhere
       or catch the Ting anywhence
  
   there are always a bunch of todo items (above)
    when we come around and out of a thing we need:
    the testable Q pipelining gear:
  
  &Aredo does it
   for ~Q, which we begin to fire changes at
    while|not in %Cat time
   it also does for Xlv (X:diff)
    as ~%Te will be understood
   pointers to J**/A** affected
    ~ @Gump, who might W/W if %Compiling
   does:
    keep winding cv/ov if < 7
    else el:2 into an el:3 A^^
  
  &elvis out of %Cat time
   they can work $P, decoding
   wait for all Pending before &Abelieve -> Q
   heuriste A..A time coupling
    expressed on cv-scale?
     the notion of things being in a space
      that may transcend any other separation
      everything over here, or everything over here
      the continuous variable
    so the exotics collection process can straggle
    while the immediato of the happening are got
     eg W:Fingo + W:Story/Fingo mostly?
      or is it W:Good, the quest to 'be good'
       which may be Storied about
      the W:Story/*
       is a T room for W:*, inc:
        how|where it is running now|sometime
         %Te interchange
       distributed what-is-known about a W
       including bans and promotions
    how coupled to the time above it
  &Amess <- @Search
  
  have $C = &Yingbal for ite
  &Athinging waking by the lv it detects
   to proto A:n about it, &t at the A.1 etc...
  wanting to miniaturise &t
   getting async messages (de-)fullfilling requests
   that then &e to their use
    if still connected
   taking a bit of 4..3..2..1 pointing|caching to
    ie &t el:8 @4 -> @3 (step) etc
   the J.t are the quickly and surely resolving $n
  
  < -seven things per &com
  < Gome-Control sensors for the This space
  
  &SuperGome
   and being in @Intro, for uptake
   deals with its having a life of:
   $t%modes, eg:
    Fish reiterates or $tid++ depending
     A finally will rebase recent change onto a branch,
      and rewind to before we started messing with it
      eg last Story/Point attained
    Displaying
     to @Vis
    Duolish
     wait for clicking save
     on allok if a test
  
   periodically:
    pack up when bored
    do parts again if it blows up
   interaction:
    or if e want to relive any part of anything,
     delivering differencing
   mot:8 auto
    &togcon endpoint these...
     are pi C coordinated...
   mot:8 += el:8, should wander into the thing slightly,
    check its es,
    perhaps it is routing inward without needing to wake
    
  &supetime
   'reset?' should reset later %%supe
  @Introtivity rehijacks:
   uptake|outtake:
    new w:Fish should happen in place? how much?
    grows another Travel $tid to cover all that might ~
   datamine:
    attachable R:Display subselections
    climber + encoder
   left+right deals big to the humans
 ..we
 
  while being in @SummerCat
   to lots of $W at once for tests,
    upGansp them as usual...
   way in from &Zeve outside
  
  out|through -bo (brackology)
   wants to group dome+supe+sute
    since there are so many
    yet not say %dome=%supe+%sute
     by seeing that $dome.includes($supe)
      it could pick up other encodings as syntax cues
       very
   setting %attr.title to something to X.tv
    new &e on Element
     finds its way up to a:
      &isnode having some id on the step
      steps having some id on the Ying|4
      Ying|4 maintaining self.Ying|4 by name+time
     A.1 may be pi, A.2 not
      A.3 under A.4, A.4 at the top (self.tv.*)
  datasplay
  w:a is your headroom
   walk it around every so often
  
 
 
 
  <<<
  not stops working after a while...
   where you are typing needs to assure connectivity
  saves the list of the music that you have
  time smoking, seeding, watering
  Nodar
   map in Yingu
    global size control
   forms filling out larger
  
  Jay produces displayable
   each W in Jruntu
    each Yinging a bunch of awake
   Story has sensors here
    could be used to restart, acts
     this being a pi in many places
     which doesnt need to wake much there
      ie tiny dom adjustments
    having the is-waiting-for,
     coordinates to anywhere in the think (At path)
  
  @Fish Jayeration
   w:Dome for A as A...
    mounting brack in A&z may get it done
     see w:Fish, A&Super* / X
    so will C/** with y&A, eg A:n
     take things to such cv level,
      they are like nodes, A.y.up etc.
      everything we R|s is renewed
      most things take A|C non-fatally
       and notice C!=A, sometimes
       &Xint-perception of Normal:
    lot of falling and smashing in the universe
     mostly disguised as chemistry
   game of telling everyone of a word
   word-word also,
    &togcon for things,
    descriptions of their locations can be compressed
    in b-space, a sensuous thing subset of B-space,
     which encapsulates any call in A.I
   
   some real good simulations of the fundaments of the above
    Ying loops, etc.
    wanting Story 2 boots Story to that degree.
     makes up a new Stori, with no clear beginning.
     just to get that gear to graph out the think
   and the below:
    @Search gateways bring entropy
     are based on {c},{sc} bracking
      it will want a big intersection to see what data is doing
     its a stream certain things might hijack,
      eg to interrupt compiling
  
  A&Super*
   is a procession of brackdoms
   playing out a process
   propagating changes (el:?) to brack things
   these being an A progressing
    sometimes not built up all the way
   locating another A to su*:
    surprise (dome el wakes)
     to subscribe, e a selection
    supplant (.up.X replace, is that new self|R)
    sublate (we happen around+with that)
     to mix in, to e parallel, etc
     varying degrees of switching up another As function
      -lies want to pull up beside the other
   
   having A.s?c that are surprise to X.b
    or being reset
     moved from s&made to an apprehension of s&made in the past
     and that knowing when things were set ability
     scanning every known (from the top) A.*.* for some level
    io should relay datastructures it changes,
     and doing so should be via y&e (connections here)
     so s.*.* will cover all official change
    the &ja behind a &t
     is its subscription, will brack into X
     if beyond A cone, link up
      the A:t (&t) is a generation or adoption of a $P
      which may async|other
   X wanting to be per A that builds it again
    has an Xb of everything that came before
     (Xb is very hard to pronounce: click-buh)
     we supplant entirely, may have goners
     we sublate, consume matter or extend mindsets
     we surprise, wanting correspondense, fibre jets
    the processions of stuff wandering along
    domes of A:X engaged to begin things
    they are trees, bits rebuilt and recycled
   A.I=X, thence having a builder
  
  Frame
   apprehension of a thing(s) about this thing
    eg &I, under &t, grabs a whole thing
     reads X:A.I, mind stored of/t/cv+sc
      see Pictures &Kmish
    is the overall
    thing, where A appears
   you are already part of a call that makes something happen,
    eg &I collects immediately mindable things
     for diverse kinds %of thing,
      searching subscriptively to some A.X
       A for each thing can be found on the @Shelf (@Sea)
        since A&ip replace?
     the &i is the fatal-er version of it
      for function calls
    &t specifies a thing for inclusion
     
   Ay&$pi may happen (perfect), are also A.$pi
    the bit sort
     redo -brack, it looks through and does stuff
      X and brackstill have changeyclues
       a brackstill on only what you selected
       while other energies lap in
       may require waking a thing to where first
       4
     overlapping bracken rearrange
     making tables to regroup things to
      see 'left+right deals big to the humans'
     must go with the suggestion:
      stuff in A.* may also be in A.y
      that is a subframing
    even -Api, shared kitchen
     knows which A&X.$k have $pi in them
     most X would notice if pi
     it is a scan sense, for many at once
     something to learn what ever happens
     
    https://youtu.be/bWrNxOA5NI4?t=3736 
    
    and from the beginning,
     put wjs/boot.js in an A
     do something directly (no &h) from it to:
      setup G.h|t directly (no &h)
      A.5 has u to revive from cache, check up on later
       boot-priority must all be wjs
        such that they become higher quality processes later
      A.4 has n to revive from cache, etc
       W:Fingo
    
   # < Codon Babz '&I =' -> 'me.I ='
   #  < Babz
   A.I.$of.$t.$cv -> &I = &acgtcs{
       $I = c.I || A.I || &I,{up:A,sc:'I'},{}
       # < Codon Babz '&bracko,' -> 'me&bracko,'
       # c can go I.up and A.up+.I
       #  callback on such slope progress,
       #   to be cancellable and|or parallel with other routes
       #  is a way of selecting C with N/X (c)
       #   a multiplicity of things we are looking for
       #   notice indexes of I thing.
       # c is, unless marked out, about sc to match
       #  c={gks:'sc'},sc={findables}
       #  may include sub-thing matches,
       #   eg s&find with s&find.lingy&cv>3
       #   built from the tail,
       #    it will need to swim before it can see
       # everything in s must be understood as mode of &I instruction
       #  or it will be &bracko's sc,
       #   working on whatever lingo context the I (X) provides
       #   probably el:2 t:somename
       #   that brack ^ becoming in-dome for the enclosing A
       # c can c.sc=$gk, or c.sc={findables},c.c={howto,gk||=sc}
       # &bracko -> &route? find endpoints for startpoints
       $N = &bracko,I,c
       # s has types of want-thing, or fatal
       #   &jaa above this, to do a bracko thing
       #  one - one or none
       #  un - one unless we never happened
       #  none - none
       #  some - one or more
       # non fatal:
       #  any - if one or more - avoids creating for nothing
       #  once - halt if whole replaced
       #   s.* should change if s.*.* changed,
       #    s remains itself, as made a stream by osc
       #    fibring each thing it understands (s.*.*)
       # may el-2 it, etc
       each in N {
           return nc&s
       }
   }
  Subframe
    in-C thinks, $gk and beyond,
      eventually reaching another C, or simple space of C
    s.*.* per s, as above we were considering them
     across many potential s
    each quality is in a space with others,
     eg cv set order
      then once cast into A are sliding downwards...
    A basically tractor unknown A.*.*... <-> known A.*.*
     all A.*.*  may be copied to A&X, to be noticed
  Forces
   are motion onto mostly-previous-existing space
    eg surprise, brings new A into place
    highly dependent on J+A sub-time markers:
      dont leave the time-capsule
      get related via X:
     A&ip for sheer A sprawl
     A&op for push-pull to X point,
      finding what itself is @2 (arrive)
      attempting to el:8 it,
       replacing Js&s
   are debt being chased down
   exist in subplots that Dome, &Ying_8 etc
   X is a log of a force being matched
  
  
  &ManyGome
   an evolution rather than checklist &supetime
   the universal hanging around end of $t
    tracing ornamentation, muscle memory
    openness indexes etc
   to track, via @Sea:
   each Gome (per $tid) is one of many Thises:
   be the ever thing, (Fingo/)?@Around(/$t(/$tid)?)?
     (and Fingo..$t...?)
     Gome/$t
    data patchbays
    listen to /ws/Fingo/Around.7,
     includes a list of times Fingo/Around/$t ever changed
      Around
     W:Fingo commits each That/$t%dige
      as they are cognised by 
    $t (Stori) might as well be anything,
     and have further things inside of it that you may also subscribe to
     < the chatroom
     so one thing can compile & test a /wjs/
      then send to:
     alongside:
    W:$t (wist)
     place That we store Travel/$t itself
     might be given a That/$W/$t, eg W:Fingo/Fish
      w:Fish may affect af.*
   can randomly find we are running
    from Travel/$t%play
    
  @Goting e
   updates or user can $tid++
    <- &togcon e-nergising
    <- parts to read again
   < turn on elQups again,
      or have a one-click W bump
    may cancel run & restart another
     or, keep run, merely +T within %SummerCat,
      to re-@Inc those changes,
       probably saving the same W
       as if done from the top (new A.4)
        < notice if it matters (J&el:2|3) in spare time
      leaving update streaming pipelines
       in place for a while
  @Goting
   make %%finished..
  
  &L
      Index to contain the Search-ness, el2ing
      hmm:
       C 1 parses, expands
       C 2 realises idea
       C 3 creates body
       C 4 CNS acquisitions
       C 5 purport
       C 6 generate
       C 7 traction
       C 8 dialect
       S t 
        K only really minds the %dige it is...
        &Sea that bracks things
  
  Travel
   < lie and times
     going them
      perma diff interface
        Dy&parent
        is nearly &Accept again
         with an &Effect that drifts on the %%Go
         and then establishes instant pause, <7
          graceful teardown, etc
      T may $tid++ and|or engage Story
     %%Go -> Travel
      if $tid++, cancel run and re%Bat
     Duolish <- %%SCing
      suspend @Gu* while pushing
      commits $z|$K in To|That and Ghost
       Know are a mot:8 once all Ghost for it are the new version
      notices gone $z
       makes gone unless run is %%noncanonical
        @Guten %%mot:9,nomore:$K helps %%lonely el9 $K
    
 more timeliney: 
  @Gump
   enables elQups, so %Paving happens on ~u
    needs to route the surprise to it... pull P->Q
   receives new %%chag, even while &lock
    can &jaa,@Goting,{K}
     which leads n-ward to the used %%chag
      which are 1 u-ward from %%cha, in %Paving :feels
     and has %%Goable:$t
     finding %%Go:$t,tid,eto:@Gomes
    bringing us neatly around to:
  @Goting
   make %%finished something
    bring on the job whether mot:8 is about to happen
  @Gome interrupting
   decide to redo immediately,
    or keep publishing slightly out of date stuff
   &unlock and insist on that same %%Goable happening again
    others may want to happen also...
     Travel/$t might have a relevance to now
      which evolves. a quality in %Loc of the editor.
       some of its pointers squishing together
   
   %SummerCat should be able to:
    @Jhost
     loads the ~u
     < receives a bunch of Q-ish that we Know it will probably use...
      < know when it doesnt use such thing
        and when that means de-u it
        being canonical run, or not 
    @Jproto
     can tell ~u and redo relevant J
      warn of ~u we didnt expect
     +T or so, does from the top of A.3 or A.4
      by @Step-like will and @Gome round-ality
     multiple A.3 %Compiling into each other trick
      osc plan shuffle matrix
    emitting the latest storables
   
   so the $tid neednt 'finish' unless it really wants to,
    something will have to tell @Goting it can do that
  
  &supetime
   'reset?' should reset later %%supe
   X coords Domes, as %%dome
    the past is a %directory that waves crash into
     %twin|%Paving structures are X plot paths
    &nodei, &nodeo, &jaa all save their acgtsc
     muscle memory
      ov-er time
  
  dont need asap for a while...
     new A though.
      me&AMindness should mix into it
      start a Radio
      vary %directory
    the index thing that is wander-until-C,
     picking up %directory, etc...
     spec as io, .path compiles to %adhere etc instructions
  %SC text
    look for &subs
    if expr then <-> expr and then flipper
    AllBabz - test Babz changes against everything
    jumping through many points
  1..9 code..phil, levels of knowledge to attend to
   &supetime
    < fodder for influencing new A
    < has &ty buttons, in %%supe,sute,$t space
       the callback may alter a jaa suterow,
        and then notice it in zaa to impulse...
      its about the handler being self|other,
       eg &rolltog,R,'val' works by only R%val=1 in other-time,
        returns to the self, notices b%val and acts
       eg &Effect (may be) able to happen completely in other-time
     < being automatible (%%may...)
      
      
      Story+&supetime
       given columnar -sevens and Nodar lasso
   
   
   < %%Releasor back
      grab moments of:
       may Story prepare
       -> Travel..
       Duolish:
        arrives, bumps till:
        ready,
        
        push,
        pushed
          %%cha capture what we did,
           to pull it out of noisey environmental %%cha
        
       save W
       Paving adjusts %%cha, maybe new 
   < &unlock
      Zave%allope rolls until switched off now
     or packdown,
      asap or before push
  
  < auto show twine %%thing!%%extra %string <20 lines
    when not auto pushing...
    
  io
   < i $su/@sum y o $sum:sum/**
     ^ has to be i $su/@sum/**
  cm
   < mode/perl/perl.js:700 ?
     to only select 'this' of '$this' when dblclick
   < BabzLook - see selection compiled
   < DoesJust - see selection run, returned -od or -dis
      space between %Cit and &Display and &osc
       hold a part of the expression
        split at = or return, etc
         cm.getModeAt()?
  Story
   < Story invoking for @Gump..$tid,
      or any time|thing
       Story takes %%Go as a thing to test,
        it could be an &Accept back in @Goting
         or some wakers[] to resume
          < wants &waits_7|8 redone
            should act the same,
            then add info trailing into the thing
             inc reason, T.act etc
        knowing how to &accept|init it when ready
      as opposed to Ying beginning
     or we are being invoked to catch on to what is
     which should be pretty quick...
     %Tool for moment nab, etc
   
 <<< Guten Story:
  @Guten is a -groupbrack*,
   making shared things span rows
   reducing to just a few words
    a limited view of some rows
    expanding into -pi as clued
    or mind/world breakdown
  
   < %%may:el2
   < That...%P == Know...%P is n becoming u
     or it read/writing itself
   < That want pull if others write it?
  
  @Gu* prescribes a Travel/$t
  
      
    
    < Duolish get abandoned, tidied
      poke if quiet...
      
   Know..$K commit once all Ghost..$z are the new %dige
     
  @Gump prescribes a 
     That..$K commit when pushed
     
     
   %SummerCat has no Ying inside,
    < assemble a J-centric alt %Ying
      then should be able to inside all outside processes,
      by deceiving Nodar that they are where they were
   %Compiling:
    sit there with %Paving listening
    makes %Bat-ches:
    - build (%SummerCat, w:of)
    - save (Duolish)
      or restart batch if u not as it was
    - websocket push updates (e:elQups)
      via /chat/$room
       with a first line that goes $from\t$to+
       $from becoming routable down that socket
       then Lines (or whatever) from there onward
      of something mixable onto the previous version
   %Bat:
    has an act (build,save)
    a validator (u still as it was)
     may abort or reinstruct act asap
    then success (push updates)
   %Tat:
    what of the machine
    so it may be injected with ...
    eg hijack Ying_8 when such -seven-ness
   %Tea:
    reantithesised &t
    making the basic c&el receptivity...
    inverted c+sc?
   %Twi:
    that joinery of %twin
    an Index thing
    so is rebuilding it, diffing...
    
  <<< Story sitch:
   break? possible and happening
    on %SC &Yingbal - the interesting thing logger
     would rather be interpreting:
    from any -log, -gate etc?
     
    probably just to &Pageturn_suddenly
     or fully %%quiet,break to also allow Storying
      until ready: Ying_8 resumes
    implanting them should stretch L%Pages (gen from $t)
     and make $t/$expr to accept (autosave until)
    then $expr inherits to the next $t,
     maybe the next L? (checking between)
   entirely new @Search
    %Jproto and Story bound while waiting for responses
     test of:JaBabz asyncs all the time
      have to be reset over the first time
    
   
   Tare:
    repel into machine room,
     each stop knowing how to replay to that stop
    asking above about each thing that turns up
     &togcon including A, etc
    &tar: c,sc find a thing, also asserts
     c=t - may use W-context (%director)
     c=of,sc=t -> c{of,t},sc:{} - not W-con
     c{of,t},sc{bp} - %bp=SomeBreakPoint
     c=$W,sc{Y} - some $W (A.4/$C) having **//$Y
    where the c are matched exactly,
    sc may be anything identifying,
     or el denotes an act
    rowc&z=[bracks,its,inside]
    rows&z=[rows,inside]
     bracko should go into them ^
     so &t can eventually use many indexes...
     brack meaning a row with a z...
      suppose they can be bump-versioned with brackstill?
      and check each way up until out of ~A,
       in case the whole brack is replaced and nobody told us
   suggests savepoints:
    eg each time %Jproto -> %Jrunto
    could dividable $eight, know when to %%quiet
     this be a Nine/$t/$e? T-roomination
    they could be looped over
   
   things
    test ex() and so on
    chunkify some code
     lex code defined and use
     sort Yingmind and Rmind bits,
      show when they are called
     %CC - CodeCode
      needs gone-able nodes
      ack
    -pipe - a self|other tool
     re stylepile, etc
      some tunneling only for Display?
    %Ear to the ground (new %Search)
    -lv - hoist stuff for Display
     show %mundws, %Search being subjected
      worker threads
    Display:
     receiving -lv for it
     
   Aearch
    wants to be a brack compositor
    &t reads rows, gets confused or allows multiplicity
    
  %Story:
  < &Pageturn_pretendnow
    getting us beyond the Point++ etc
     by sweeping it into the previous Page
    is really about L&init happening before its first Page does
    probably forget it until there are pockets
     of language solving at different times
  < Around-ness until -pipe good
   Around having its $W/*: %Paving/%Caving
    for clicking which one to be Around%head
   and each $W=Stories/Around/Nine
    with /time-trail of runtimes
     to insert to on Plot%alldone
      and each Nine/time/$L-trail also (point space)
     select $seven-gate deltas..?
     'hoist deltas, to prove faster when'
     < fades stat compressily
     < with ghost versions, lv-compressily
  load recent Around-ness
   push|pull Around%head->/Nine%about ||= ['vovol',Nine.t]
    do on startup if %auto
   these %Paving should anyway be faster
    also the wandering Nine<->L init
   a new first thing to do (was W:vv)
   no checking until L%main passed
  hoist deltas, to prove faster when:
  noDisplay $seven
  
  
  receiving %%Go to start a test (become Around%head)
  ignore any $eight in a L%Fugue or L:Wander
  $t/$exp - something to unpack unto L|Eigh
    'repel into machine room'
  $t%erm - error margin, fraction of lines diff til !ok
   < ignore ^\s+(\d+)\t/
   < makes Test non-canonical,
     to run through without noise daily
  
  -Will intersperse L, gen Nine
   will to ignore 'beginning', only Easiness
   will to repeat to measure for determites (Dif)
    inc eg such R-time matters or not
  Point_ology|ness
  
  Slopality figures a Point-show for any Point-related thing
   and some types to assume flock
    A Cardinal Number is a number that says how many of something there are, such as one, two, three, four, five. An Ordinal Number is a number that tells the position of something in a list, such as 1st, 2nd, 3rd, 4th, 5th etc. Most ordinal numbers end in "th" except for: one ⇒ first (1st) two ⇒ second (2nd)
  labelling things properly?
    new Nine resets eight.t scheme
     i.testname.i
    showing joined info shaded...
  gen Points from exp,
   having check:2, add next Dome if unclaimed, etc.
  &t outulism:
  use
  require 
  Cit tiny mode: s=0 shows up as ?
   
  combine Jx, inode, acting
   see '< all this in one:'
   TheEigh wants to be &acting,'Eigh',
    this could be 'The^Eigh',
     similar to the way css names shorten,
     except this would keep the later part
  
  Stories/*
   going async, when init:
    causes a says:Q-0
     each found causes 20 lines leanience $t%erm
   being unpredictable:
    when loading Stori:Easiness from the start
     Plot%Te will keep it around
    so we would know the exact nodes,
     to grep out rows including them (before serial numbering)
     should mostly work?
    <> from only knowing 'extra nodes in Stories/',
     might have to -vat early (can be per ref?)
     or diff re -n back to 'extra node'
  
  for speed
  Plot%Te may specialise how to run, eg:
   loading Stori:Easiness from the start
   
   how often to stop and check answers
    beyond L%Page_out
    which sends %%Checkable around,
     or -pipe can other all the work to get -eight
      and make Eigh seem %%ready,ok to Nine without visiting it,
      
       
      such that a trip to Nine then thinks Eigh...%%ready,ok,
       without visiting Eigh
     starting from the other:$L, 
    
  $t%fourdige:
   able to check only -four
  $t/-four:
   could limit/exclude certain rows,
    or rows with such node, etc
  $t/-tail:
   the last few $seven on the page,
    in their own -eight|-four
  
   < -four+-seven noticing when %%steps covers all steps, etc
  
  < create an adjustible regrouping,
     for a running out of space for Xrefs
    save %togcon for it
  < do that -group* test in a %SummerCat
    word crossref, sorting out the aspector:
     me&Kmish,Z,{for:'K'}
     maybe it is a &ha server?
    then %togcon savior
  
  < fork Abodo, get this working on modern chrome
    is mind othering
  < TEST arq() etc (lay a unit test)
  
  < able to other shade, Plot/* the stylepile
  < more Plot when eg Gump streams
  < better /ghost/ er 500: multiple G/gam/Pictures G/ive/Pictures
  
  < %%Acceptable<->%%Checkable:
  Plot signaling:
    ends ~ Eigh%%Fin=$eight
    Eigh commissions $eight|-eight to Y with %%Checkable
    < send Eigh a &storable image of -eight
     < this could be -eight.y.P?
       Live.y.P also, from %Search.
        the P should y&up to the producer of it
       then &selfThat encountering LyP from %Search,
        etc
  
  < Plot/Look/subtasks:
     starting: beginning,le-1: W:Lingo,Story**, til %%quiet
     oking: le2-3: of starting, exactly, til %%gotupto
     oked: of oking, vaguely Nine is so far ok|not,
  < Plot/Respond:
     repeatable instance of Travel/$t%SummerCat
     load the Stori for it
      < Aline in Story/vv/$t or Story/$t?
     a Travel/$t send to Travel/ing/$t-$i for runtime
  < Plot/** will want to continue, or:
     period of self analysis may -> ReNine
      then becoming ok
  
    < through Eigh**/-tll (thing looks like) to Plot/**-act
    < %Yingates are Y:-eight/-seven
    < thrashness dampeners: Nodar other mapstyles
    
Story generality
  < Yingu pause, &whyloop... 
    -wants back to the %%waits sources
    fastly codifying motivation to notice looping
   
   < tunneled R should wait until aboves @3? (sleeping or not)
     unless directly &Ring, as Ying@296...Y:Steps does
  
  < the pristine unconnected toplevel inside %SummerCat
    is the pile-to. get some stuff made... etc
     it leaves those &bal tracelets
    make a separate $me
    make W:I/... from ghosts
     %%eto unable to retract, must be constant signal
     nodes may delete etc?
     the Pearch that lv-ifies news,
      compile-checks stuff
      talking to websocket about names to wjs
    
  < Ying waiting for all &t waiting (%SummerCat)
  < highlight $D outside of Ying, ie Dy&inside!=Det
    e circuits:
     whether to Dome (and forward to &settlers)
     the new, or keep it on A branch for others to incorporate
      it appears to be the thing via others &t
  < -eight implies /-seven, etc
    seven gains c&type=gate|log (previous c&pi)
     drink?
  
  pi S, to a &throat
   the things that notice things
   pipe + settle?
  
  waves of unfolding mechanisms, locating simplicity
   leaving a C
  
  < Story oking Story starting, oking:
  < 3 should see all Checkables OK,
    else
     page(diffpic), page(accepting)+
     discard -gates until done
     also:
  < 2,3 etc should be within Story/**
     wantswander
  
  < to match fuzzily, -four only, etc
  
  < bisect the startup error
  < 0,1 sometimes merge?
  < &Yinge: drop stale Yingvoids across reset %Ying.
    er:NOb sometimes
  < Rescaping.
    notice which R:ruv mindbits are used
  
  to get onto text diff pipes, Y doing pi, could be pins
  < &Jx modulata, see &Acceptings
   < merge &Jx+&acting, hooks that do &Acceptings etc?
  < pipe have Y:Story**, assembled with:
  &actin = &acting + make pipe, etc for most nodes
   h - keys name: G&t,acting/name (simulate)
    h.* = more h for that thing
   the several things of acting join up
   something Te-ish turning to lv mot
    so Stori can instruct Y:Test
  as a Test
   < Plotting over the intro, doing a test,
     with some -six: Nodar pictures
   < Y handlery, io-hooking:
   < as a Test
  
  %TheTest pipeline:
    -eight & pull Stori**
    -> Nine/Eigh -> acceptable -> ReNine** -> push Stori**
   pull Stori -> Test/Nine:
    begins with &getThat,
    %%eto:K,pipe:Test,efrom:Test,species:1
    this allows &twineThat to find ^%%pipe,
    %%eto:K/**,pipe:Test,efrom:Eigh,species:1
    %%pipe:Test for everybody.
    Slope it out here, there
    find other parts of the Stori process, etc.
    intake what you replace:
     < to pull our push
        Eigh may pull %%acceptable,dige
     < to push our pull
        ReNine only push %%Parent ?
    comes down the pipeline somehow
     < all the way through:
      < Y:-seven parameters on encoding live...
        which you might be collaborating on
      < just apply patches to your idea of there to rebase
  
  nice ideas:
    brute diff around whole TheTest**
     showing where it was made linkey into Nine/Eigh
    pipelining as in io plumbing
     joining different paths
   
  Eigh diffs:
  < difference -> -eight/-seven &brackology
  < with more pipe:
   < s -> Y:Lineso, knowing:
     s** change per magic input tension field para.
      how to encode|mute things
      how to recycle index
       so we can merge tiny code changes fast,
        run out of entropy (index same)
        consuming from the index must be more pipe act?
     s** per line out (index)
   < difference joining index+
     < patch restatily regroups new|same or same|old
        to whole lines, like `diff`
  
  < -eight &brackology sum, spot any Story**
   < &wait_8: make pure Story or not -sevens
   < all the whiles to Story** separated from run
  
  < Plot deciding:
    which -eights to discard as fiddling,
    which -eights really matter (match exp)
    and whether we can continue the Plot,
     or subplots, from our current state
   
   begin:
    chases, oks D:beginning
   Gumping:
    selects jobs (testruns) to do
   
  < drain monday
  < sub easy ioings
  < colourings
  < Fiveplan
   < small scrollspaces should not scroll parents when maxed
   < scroll headings|lines on the left|right side 
  
  < fix occasional nob on Lingo%Peace:5 for Lingo%Peace:4
  
  see Story
  < auto The/vv -> The/Lingo? the Know tour
    or is it a Lingo 'beginning'?
     eg W/t/iooia has env|Launch stuff preamble,
       then dome 3 contains W:t/iooia and more domes
  

Yingu and Story
   Story finish, groups Yingu,
    tests with their &waits_8,
    lv of the s changing
     as osc visiting its C
   Yingu live/playback from &waits_8
  
  < put more id in &settle row
    esp on the %%waits,wants of &settle_7
  < &settle_7 notices when new version == a pushed version (%%for:settled)
    eg the regular %Pave!ready bothers %MayTwine &settle Know..$s
  < settle upward with %onlyish, eg %MayGansp <- .../%MayTwine%%thing
  
  < Story<->Gump, soft &settle everyone else
  < make go:
   completing the circuit, meanwhile:
   
  < new &waits_8 should fix at least half of:
  < test up:
   < wake on el:2|9, $s/$n pointer to the not yet node,
     so %twmt adheres from $s to $n
      see Rs&numberclicked
      < %Peace: assemble types sleep-agnostically
     and then %%eto:1,tw... gets to That
   < then To..$n comes back,
     having pushed itself to $later
     or having subscribed to changes to That %tw
  < sy&twinned, forget $p
  
  randoms:
  < %%eto clickshunt pseudosurprise
  < %%acty?
  < doublethrow: show first stack
  < try/catch when we Ring a whole step at once...
  < brackism, eg %%may:input
  
  # < indot Y nice:
  %Abodis,Yingu
   flashing lights
   pause, circuits, unify brackism
   way to consider the dome before running into it
   < explain/control go round
     sliders for attention span, energy
  < adopts %Nodar, when its not lining up with something
   < realtime nodes waiting/waking
  < exploding certain elements from within Ying,
    making rows, adjusting layout, scale
    &Yinge
     < coinciding &Yinge not lost
  %Abodo,Ying:
    scrolled window + onmousemove:
        var x = event.clientX, y = event.clientY,
        elementMouseIsOver = document.elementFromPoint(x, y);
     track anything, scroll everying
      to keep still relative to the mouse on update
  < %ball folds, aggregate "all ok"
   < brackdiff/%acty pop out
  < conclusion: bleep, bloop
    make go round nice
  
  %protoJ
   whole new all it takes:
    u mixing from @Search intake
    doing with that
     A &throat, &Ying or &Ring
      A-thing sets up A iterator @o2-@1
   with %Ying we may:
     display as a thing|thinkypile
     display as an appearance
  
  %SummerCat:
   for compiling nice code again, I:[neusiolaND]
   < for a Story (Gump actuation)
    < shrinks away eventually, contibuting:
    < runtime, several scales of it,
       as a %Yingbal (interactive) thing,
       as storable encodings of them, (&Ste*?)
      to become test data
      < %Zif wants to know how to work them
        runtime diffing
   < testrun etc
     also scooping up extents of Yingu smoke
     < debug Jpara+settled+testmode
       might be html
   %Jproto:
    < fix sometimes dupe %%eto
    < 4s&callback - possible override e
     < then handling the onclick event,
      < new Display inside
    < carve off history: Rc&b, yfuture...
      begins:
       J located in bc&sc&J (if Y:n)
       Rc&V is local history?
        dialect of two variables:
         in A, a J
      how/when it applies:
       J callback all inside R, as if Rc&N[0]
       Y seem good
        replace their previous syY, which was Yc&b?
      will need:
       Index climbing
    < Te
   %Jrunto:
      < Y:n the grounds, so they can mind
      < Y:u configures dialect, etc
      < Y:n,S, with try/catch liberally
          S for wandering through c&pin sections, domily
     
  Y|A
   leaving unfinished
    throw:
    < should be detectible (Ac&T.act?)
      aborts everything until catch,
       non-descendants, eg A:n continuing A:slow doing A:doing
       may not garbage A:slow. depends on lineage?
    T.hwack:
    < requiring the enclosing thing to know about T.hwack
     < or becomes a throw
   may be used in %Yingu to create works that may be done,
    eg encoding a certain way,
    displaying more stuff:
     giving an output Re-cipe, like &%Yingbal
  
  
  Index:
   < drains %twin, etc
   < for Q.c.* using &fiu for:
  @Near:
   Q<->P again, proxy or http
  @Search:
   < using of:js again. add dige lookup?
   < of:w 404 should el:9
   < Search:wjs should never think theyre ready if !wc&code
   &Ghodig:
    < cant update to a previous version
    < latest wjs:Yingmas if Know...wjs:Yingmas
  %Pring
   A bunching of things heading into them
   %Slope to see
   < check bunch of P are ready, wait max 2s
    < can speed up Qready (thing for batch) -> Qup (batch)
    < e:pull returns when ready (@Search Qup coordination)
     < G&t adopts %Elvoids it asyncs with (%JRom 8)
  
  < brackology tunnels?
   < %%dome as the most-separator
   < open column nicer
   < show %Aearch/@Search Ghost,
      args put later than t
      Ghost/$of should know its index:
  < singular %twin (index of eg of/args/t)
     
  
 CodeCode
  < dream up something simple
   Steps Dome
   / means z
    to complete & test a bunch of features:
    < %Code pointer more infinitely
    < allowing rearrange of W:g-j as list of $t
    < weirdness erupting, normal quiet
    < A == R, etc...
    < sending patches to your Search host,
    < jsba, tested against everything imported,
      and all remaining js code...
      < need.js for linenumbers: ServiceWorker might:
        return new Response(null, { "status" : 200 , "statusText" : "I am a custom service worker response!" });
    do the srj:
    https://artem.krylysov.com/blog/2020/07/28/lets-build-a-full-text-search-engine/
    
 
  < Words:
  < track <
  < boost<0 that ope=0.5
     the bit of nothing next to t being half it
  < not
  < hsl l is not dark enough
  < the %ein(C) interface for %_ting
  < ch()/G&c says harvester, put in A
  < me&way + Search from the top, its own mundws
  < me&t should know about ways inside ways
    most of them will static args
 %Slope
   finds neighbours
   the center of the findables
    %ball, %Cit, %Zavmo types of sprawl
 %Differ <- Textl
   text relationising lab
    defines %Here<->$P
     how to push, pull, what changed
      how to i/o or patch bits of them
    breaks down patches
     important lines leading into what changed
     chunks compare with each other,
      to get moves as low diff gone<->new chunks
     chunks accepted as forms
      for more chunks to be more acceptable
        when the same ish change occurs in many
      2 chunks should show the most residual bit of identity
    sees t y c sc amounts
     such that the same code works any model:
      %Code/%Line/%Ch
       everything slightly t, the name of something
        esp heading positioned, rare words
       c more the syntax
       sc the knowables
      %Cit/%nkness/%gkness/%someindexes/
       bits could be found in the code
    make steps for CodeMirror to unfold subdocs
   makes pointers into code,
    is wanted for:
     %Codo search, %Abodis pointers
     %Code unfolding
   logisticises processing:
    Babz translations resyncing parts
   know %keyword
    or the ones from such a Ghost
    &ind-ing for creativity
   chatbot
 T
   another thing-ink dripper:
        #        $he = Rc&N[0];
        #        $i = hes&inti = (hes&inti||0)+1;
        #        me&tsc,'%Zave',i+'th','y';
        #        i == 2 and debugger
Zave
  ghost not auto direction flipping?
  might be coinciding push and outofdate...
perl
  which version (got or spot) is best to elvis work to?
   it could be rebuilt from a forking clusterer
    javascript -> perl translation
  < Babz array[-1]
   perl is weird how it can take this ARRAY as a single argument:
    push @{$between[-1] ||= []}, $_;
cm
  folds open/close antiscroll
  likes <100 lines on screen
   < not Infinite height?
  ambient state checkup
   shui:casual cycle wants insurance from ...
  keys:
    Tab in \S\) should jump over 2 characters
    e:A+* elvis while paused
     something for tagging the line
  later:
  < regroup Foogla etc by %Code pointers
     curate into G/
     with similar to %tracting el:9 (drop) etc,
     wanting the human to go through it all
  < move over there, then much later:
    < import git history, as if names the whole time,
       and a W:j about the fractions/order of them
      bringing back Opera-era perl for elvising W-orkers
       and all the output channel plumbing etc
      `GIT_AUTHOR_DATE='2020-02-29 16:01:02+1200' git commit`