rupaka 0.0.1__py3-none-any.whl

rupaka/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.1"

rupaka/_modidx.py

@@ -0,0 +1,115 @@
+# Autogenerated by nbdev
+
+d = { 'settings': { 'branch': 'main',
+                'doc_baseurl': '/rupaka',
+                'doc_host': 'https://vedicreader.github.io',
+                'git_url': 'https://github.com/vedicreader/rupaka',
+                'lib_path': 'rupaka'},
+  'syms': { 'rupaka.agent': { 'rupaka.agent._brief': ('agent.html#_brief', 'rupaka/agent.py'),
+                              'rupaka.agent._prop': ('agent.html#_prop', 'rupaka/agent.py'),
+                              'rupaka.agent._slug': ('agent.html#_slug', 'rupaka/agent.py'),
+                              'rupaka.agent._words': ('agent.html#_words', 'rupaka/agent.py'),
+                              'rupaka.agent.author': ('agent.html#author', 'rupaka/agent.py'),
+                              'rupaka.agent.catalog': ('agent.html#catalog', 'rupaka/agent.py'),
+                              'rupaka.agent.demo_prompt': ('agent.html#demo_prompt', 'rupaka/agent.py'),
+                              'rupaka.agent.demo_sp': ('agent.html#demo_sp', 'rupaka/agent.py'),
+                              'rupaka.agent.near': ('agent.html#near', 'rupaka/agent.py'),
+                              'rupaka.agent.parse_json': ('agent.html#parse_json', 'rupaka/agent.py'),
+                              'rupaka.agent.repair_prompt': ('agent.html#repair_prompt', 'rupaka/agent.py')},
+            'rupaka.check': { 'rupaka.check._boxes': ('check.html#_boxes', 'rupaka/check.py'),
+                              'rupaka.check._check': ('check.html#_check', 'rupaka/check.py'),
+                              'rupaka.check._close': ('check.html#_close', 'rupaka/check.py'),
+                              'rupaka.check._inputs': ('check.html#_inputs', 'rupaka/check.py'),
+                              'rupaka.check._keys': ('check.html#_keys', 'rupaka/check.py'),
+                              'rupaka.check._loop_running': ('check.html#_loop_running', 'rupaka/check.py'),
+                              'rupaka.check._parity': ('check.html#_parity', 'rupaka/check.py'),
+                              'rupaka.check._play': ('check.html#_play', 'rupaka/check.py'),
+                              'rupaka.check._shot': ('check.html#_shot', 'rupaka/check.py'),
+                              'rupaka.check._starts': ('check.html#_starts', 'rupaka/check.py'),
+                              'rupaka.check._state': ('check.html#_state', 'rupaka/check.py'),
+                              'rupaka.check.browser': ('check.html#browser', 'rupaka/check.py'),
+                              'rupaka.check.browser_path': ('check.html#browser_path', 'rupaka/check.py'),
+                              'rupaka.check.can_check': ('check.html#can_check', 'rupaka/check.py'),
+                              'rupaka.check.check': ('check.html#check', 'rupaka/check.py'),
+                              'rupaka.check.contrast': ('check.html#contrast', 'rupaka/check.py'),
+                              'rupaka.check.in_thread': ('check.html#in_thread', 'rupaka/check.py')},
+            'rupaka.render': { 'rupaka.render.Assets': ('render.html#assets', 'rupaka/render.py'),
+                               'rupaka.render.Demo': ('render.html#demo', 'rupaka/render.py'),
+                               'rupaka.render.Show': ('render.html#show', 'rupaka/render.py'),
+                               'rupaka.render.Show.__init__': ('render.html#show.__init__', 'rupaka/render.py'),
+                               'rupaka.render.Show.__repr__': ('render.html#show.__repr__', 'rupaka/render.py'),
+                               'rupaka.render.Show._repr_html_': ('render.html#show._repr_html_', 'rupaka/render.py'),
+                               'rupaka.render.Show._repr_mimebundle_': ('render.html#show._repr_mimebundle_', 'rupaka/render.py'),
+                               'rupaka.render.assets': ('render.html#assets', 'rupaka/render.py'),
+                               'rupaka.render.bundle': ('render.html#bundle', 'rupaka/render.py'),
+                               'rupaka.render.font_css': ('render.html#font_css', 'rupaka/render.py'),
+                               'rupaka.render.host': ('render.html#host', 'rupaka/render.py'),
+                               'rupaka.render.md': ('render.html#md', 'rupaka/render.py'),
+                               'rupaka.render.page': ('render.html#page', 'rupaka/render.py'),
+                               'rupaka.render.save': ('render.html#save', 'rupaka/render.py'),
+                               'rupaka.render.show': ('render.html#show', 'rupaka/render.py'),
+                               'rupaka.render.spec_json': ('render.html#spec_json', 'rupaka/render.py'),
+                               'rupaka.render.version': ('render.html#version', 'rupaka/render.py')},
+            'rupaka.spec': { 'rupaka.spec._all_waits': ('spec.html#_all_waits', 'rupaka/spec.py'),
+                             'rupaka.spec._ancestors': ('spec.html#_ancestors', 'rupaka/spec.py'),
+                             'rupaka.spec._b': ('spec.html#_b', 'rupaka/spec.py'),
+                             'rupaka.spec._check_blocks': ('spec.html#_check_blocks', 'rupaka/spec.py'),
+                             'rupaka.spec._check_gate': ('spec.html#_check_gate', 'rupaka/spec.py'),
+                             'rupaka.spec._drop': ('spec.html#_drop', 'rupaka/spec.py'),
+                             'rupaka.spec._expr': ('spec.html#_expr', 'rupaka/spec.py'),
+                             'rupaka.spec._gates': ('spec.html#_gates', 'rupaka/spec.py'),
+                             'rupaka.spec._int32': ('spec.html#_int32', 'rupaka/spec.py'),
+                             'rupaka.spec._jsround': ('spec.html#_jsround', 'rupaka/spec.py'),
+                             'rupaka.spec._lex': ('spec.html#_lex', 'rupaka/spec.py'),
+                             'rupaka.spec._lookup': ('spec.html#_lookup', 'rupaka/spec.py'),
+                             'rupaka.spec._num': ('spec.html#_num', 'rupaka/spec.py'),
+                             'rupaka.spec._props': ('spec.html#_props', 'rupaka/spec.py'),
+                             'rupaka.spec._reads': ('spec.html#_reads', 'rupaka/spec.py'),
+                             'rupaka.spec._root': ('spec.html#_root', 'rupaka/spec.py'),
+                             'rupaka.spec._rrf': ('spec.html#_rrf', 'rupaka/spec.py'),
+                             'rupaka.spec._rules': ('spec.html#_rules', 'rupaka/spec.py'),
+                             'rupaka.spec._safe': ('spec.html#_safe', 'rupaka/spec.py'),
+                             'rupaka.spec._softmax': ('spec.html#_softmax', 'rupaka/spec.py'),
+                             'rupaka.spec._sortby': ('spec.html#_sortby', 'rupaka/spec.py'),
+                             'rupaka.spec._taint': ('spec.html#_taint', 'rupaka/spec.py'),
+                             'rupaka.spec._type_err': ('spec.html#_type_err', 'rupaka/spec.py'),
+                             'rupaka.spec._utf16': ('spec.html#_utf16', 'rupaka/spec.py'),
+                             'rupaka.spec._waits': ('spec.html#_waits', 'rupaka/spec.py'),
+                             'rupaka.spec._walk': ('spec.html#_walk', 'rupaka/spec.py'),
+                             'rupaka.spec.axis': ('spec.html#axis', 'rupaka/spec.py'),
+                             'rupaka.spec.bars': ('spec.html#bars', 'rupaka/spec.py'),
+                             'rupaka.spec.caption': ('spec.html#caption', 'rupaka/spec.py'),
+                             'rupaka.spec.choice': ('spec.html#choice', 'rupaka/spec.py'),
+                             'rupaka.spec.demo': ('spec.html#demo', 'rupaka/spec.py'),
+                             'rupaka.spec.examples': ('spec.html#examples', 'rupaka/spec.py'),
+                             'rupaka.spec.expr': ('spec.html#expr', 'rupaka/spec.py'),
+                             'rupaka.spec.fmt': ('spec.html#fmt', 'rupaka/spec.py'),
+                             'rupaka.spec.fmt_text': ('spec.html#fmt_text', 'rupaka/spec.py'),
+                             'rupaka.spec.fn_manifests': ('spec.html#fn_manifests', 'rupaka/spec.py'),
+                             'rupaka.spec.from_': ('spec.html#from_', 'rupaka/spec.py'),
+                             'rupaka.spec.gallery': ('spec.html#gallery', 'rupaka/spec.py'),
+                             'rupaka.spec.gate': ('spec.html#gate', 'rupaka/spec.py'),
+                             'rupaka.spec.get': ('spec.html#get', 'rupaka/spec.py'),
+                             'rupaka.spec.grid': ('spec.html#grid', 'rupaka/spec.py'),
+                             'rupaka.spec.is_': ('spec.html#is_', 'rupaka/spec.py'),
+                             'rupaka.spec.js_str': ('spec.html#js_str', 'rupaka/spec.py'),
+                             'rupaka.spec.long_sentences': ('spec.html#long_sentences', 'rupaka/spec.py'),
+                             'rupaka.spec.lookup': ('spec.html#lookup', 'rupaka/spec.py'),
+                             'rupaka.spec.manifests': ('spec.html#manifests', 'rupaka/spec.py'),
+                             'rupaka.spec.parse_expr': ('spec.html#parse_expr', 'rupaka/spec.py'),
+                             'rupaka.spec.plot': ('spec.html#plot', 'rupaka/spec.py'),
+                             'rupaka.spec.point': ('spec.html#point', 'rupaka/spec.py'),
+                             'rupaka.spec.ranklist': ('spec.html#ranklist', 'rupaka/spec.py'),
+                             'rupaka.spec.readout': ('spec.html#readout', 'rupaka/spec.py'),
+                             'rupaka.spec.row': ('spec.html#row', 'rupaka/spec.py'),
+                             'rupaka.spec.rrf': ('spec.html#rrf', 'rupaka/spec.py'),
+                             'rupaka.spec.rules': ('spec.html#rules', 'rupaka/spec.py'),
+                             'rupaka.spec.run': ('spec.html#run', 'rupaka/spec.py'),
+                             'rupaka.spec.show_value': ('spec.html#show_value', 'rupaka/spec.py'),
+                             'rupaka.spec.slider': ('spec.html#slider', 'rupaka/spec.py'),
+                             'rupaka.spec.softmax': ('spec.html#softmax', 'rupaka/spec.py'),
+                             'rupaka.spec.stack': ('spec.html#stack', 'rupaka/spec.py'),
+                             'rupaka.spec.toggle': ('spec.html#toggle', 'rupaka/spec.py'),
+                             'rupaka.spec.upgrade': ('spec.html#upgrade', 'rupaka/spec.py'),
+                             'rupaka.spec.validate': ('spec.html#validate', 'rupaka/spec.py'),
+                             'rupaka.spec.wheel': ('spec.html#wheel', 'rupaka/spec.py')}}}

rupaka/agent.py

@@ -0,0 +1,124 @@
+"""The demo agent: a model writes a spec from the block manifests, and code checks it before anyone sees it.
+
+Docs: https://vedicreader.github.io/rupaka/agent.html.md"""
+
+# AUTOGENERATED! DO NOT EDIT! File to edit: ../nbs/03_agent.ipynb.
+
+# %% auto #0
+__all__ = ['SHAPE', 'catalog', 'demo_sp', 'near', 'demo_prompt', 'repair_prompt', 'parse_json', 'author']
+
+# %% ../nbs/03_agent.ipynb #c004
+import json, re
+from fastcore.utils import *
+from .spec import manifests, fn_manifests, validate, gallery, SCHEMA
+
+# %% ../nbs/03_agent.ipynb #c006
+def _prop(k, p):
+    bits = [p['type'], 'required' if p.get('req') else None, f'default {json.dumps(p["default"], ensure_ascii=False)}' if 'default' in p else None]
+    return f'{k} ({", ".join(b for b in bits if b)})' + (f': {p["doc"]}' if p.get('doc') else '')
+
+def catalog() -> str:
+    "The blocks and fns, with their purpose and props, as text for the prompt."
+    bl = [f'- {m.name}: {m.purpose}' + (f' Keys: {m.keys}.' if m.get('keys', 'none') != 'none' else '')
+          + (' Can have "lock".' if m.get('lockable') else '') + (f' Only inside {m.parent}.' if m.get('parent') else '')
+          + ''.join(f'\n    {_prop(k, p)}' for k, p in m.props.items()) for m in manifests().values()]
+    fs = [f'- {m.name}: {m.purpose} Returns {m.returns}. Example: {json.dumps(m.example, ensure_ascii=False)}'
+          + ''.join(f'\n    {_prop(k, p)}' for k, p in m.props.items()) for m in fn_manifests().values()]
+    return 'BLOCKS (every block can have "after": a gate id)\n' + '\n'.join(bl) + '\n\nFNS (each derive entry has "fn" and "out")\n' + '\n'.join(fs)
+
+# %% ../nbs/03_agent.ipynb #c010
+SHAPE = '''{"rupaka": 1, "id": "short-slug", "title": str, "ask": str,
+ "state": {key: value},            # the inputs
+ "derive": [{"fn": name, ..., "out": key}],   # computed in order after each change
+ "blocks": [{"type": name, ...}],
+ "tables": {name: [rows]}}         # data for rules and lookup'''
+
+def demo_sp() -> str:
+    "The system prompt of the demo agent."
+    return f"""You design one interactive demo that makes the learner think. You write a JSON spec. You never write code.
+Rules:
+- One concept. At least one gate. The learner predicts before the demo shows any result.
+- Every block that shows a value the gate's answer depends on has "after": the gate id. Inputs can show before the gate; results cannot.
+- Controls that the learner should not move before the prediction have "lock": the gate id.
+- A gate answer is a state path (for example "fused.0.id") that is one of its options, or {{"is": value}} for a fixed answer with "hides": the keys that would give it away.
+- When a control can change the answer after the reveal, the gate has "context" that names the inputs, for example "For {{a}} + {{b}}:".
+- After the reveal, the controls are live. The last caption asks one new question that the learner can answer only by using the controls.
+- Wrong options in a gate each match one named misconception. Use "rules" with "alts" when the concept is a rule system.
+- Text uses {{path}} for state values, and **bold** in captions. No HTML.
+- Fit in 640 x 720 pixels. At most 8 blocks. Write text in ASD-STE100 Simplified Technical English, US grade 9: short sentences of at most 20 words, active voice, simple words.
+- Facts must be correct. Use only facts that you are sure of.
+The shape of a spec:
+{SHAPE}
+Use only these blocks and fns:
+{catalog()}
+Return JSON only."""
+
+# %% ../nbs/03_agent.ipynb #c013
+def _words(s): return set(re.findall(r'[a-zāīūṛṃḥṅñṭḍṇśṣ]{3,}', str(s).lower()))
+
+def near(concept, k:int=2) -> list:
+    "The `k` gallery demos that share the most words with `concept`."
+    w = _words(' '.join(str(concept.get(f, '')) for f in ('name', 'statement', 'subject')))
+    gs = sorted(gallery().values(), key=lambda s: -len(w & _words(f"{s.get('title')} {s.get('ask')} {s.get('concept')}")))
+    return gs[:k]
+
+def _brief(spec):
+    "A copy of `spec` with each table cut to three rows."
+    return {**spec, 'tables': {k: v[:3] for k, v in spec['tables'].items()}} if spec.get('tables') else spec
+
+# %% ../nbs/03_agent.ipynb #c014
+def demo_prompt(concept, first_error:str='', examples=()) -> str:
+    "The prompt that asks for a demo on `concept`, a dict with name, statement, subject and misconceptions."
+    mis = '; '.join(concept.get('misconceptions') or []) or 'none known'
+    ex = '\n\n'.join(json.dumps(_brief(e), ensure_ascii=False) for e in examples)
+    return (f"Concept: {concept['name']} (subject: {concept.get('subject') or 'general'})\n"
+            f"Statement: {concept.get('statement') or '(none given)'}\nMisconceptions seen: {mis}\n"
+            + (f"The learner's first error: {first_error}\n" if first_error else '')
+            + "\nDesign one demo that makes the learner predict, then see, then change the inputs."
+            + (" Aim the gate at the first error and the misconceptions." if first_error or concept.get('misconceptions') else '')
+            + (f"\n\nExamples of good demos (tables cut short):\n{ex}" if ex else '')
+            + '\n\nReturn the JSON spec only.')
+
+# %% ../nbs/03_agent.ipynb #c017
+def repair_prompt(spec, errors) -> str:
+    "The prompt that asks the model to fix only `errors` in `spec`."
+    s = spec if isinstance(spec, str) else json.dumps(spec, ensure_ascii=False)
+    return (f"This demo spec has errors.\n\nSpec:\n{s}\n\nErrors:\n" + '\n'.join(f'- {e}' for e in errors)
+            + '\n\nFix only these errors. Keep the rest. Return the whole spec as JSON only.')
+
+# %% ../nbs/03_agent.ipynb #c019
+def parse_json(s:str) -> dict:
+    "The first JSON object in `s`. Raise `ValueError` when there is none."
+    s = s.strip()
+    if (m := re.search(r'```(?:json)?\s*(.*?)```', s, re.S)): s = m.group(1).strip()
+    try: return json.loads(s)
+    except json.JSONDecodeError: pass
+    i, j = s.find('{'), s.rfind('}')
+    if 0 <= i < j:
+        try: return json.loads(s[i:j + 1])
+        except json.JSONDecodeError as e: raise ValueError(f'the reply is not valid JSON: {e}') from None
+    raise ValueError('the reply has no JSON object')
+
+# %% ../nbs/03_agent.ipynb #c022
+def _slug(s): return re.sub(r'[^a-z0-9]+', '-', str(s).lower()).strip('-') or 'demo'
+
+def author(concept, ask, first_error:str='', examples=None, check=True, repairs:int=2, log:list=None) -> dict|None:
+    "A checked demo spec on `concept` from the model `ask`, or None after `repairs` failed repairs."
+    c = concept if isinstance(concept, dict) else dict(name=str(concept))
+    slug = c.get('slug') or _slug(c['name'])
+    if check is True: from rupaka.check import check
+    prompt, sp = demo_prompt(c, first_error, near(c) if examples is None else examples), demo_sp()
+    log = [] if log is None else log
+    for i in range(repairs + 1):
+        try: reply = ask(prompt, sp)
+        except Exception as e: log.append(dict(tries=i + 1, errors=[f'model: {e}'])); return None
+        try: spec = parse_json(reply)
+        except ValueError as e: spec, errs = None, [f'reply: {e}']
+        else:
+            spec = {**spec, 'rupaka': SCHEMA, 'id': spec.get('id') or slug, 'concept': slug}
+            errs = list(validate(spec))
+            if not errs and check: errs = list(check(spec).errors)
+            if not errs: return spec
+        log.append(dict(tries=i + 1, errors=errs))
+        prompt = repair_prompt(spec or reply, errs)
+    return None

rupaka/blocks/axis/axis.css

@@ -0,0 +1,4 @@
+.rk-axis .grid .hair { stroke: color-mix(in srgb, var(--rk-line) 70%, transparent); stroke-width: 1; }
+.rk-axis .grid .zero, .rk-axis .grid .main { stroke: var(--rk-mute); stroke-width: 1; }
+.rk-axis .grid text.num { fill: var(--rk-mute); font-size: 12px; font-variant-numeric: tabular-nums; }
+.rk-axis .grid text.axl { fill: var(--rk-mute); font-size: 13px; font-style: italic; }

rupaka/blocks/axis/axis.js

@@ -0,0 +1,31 @@
+/* axis: a number line (no y) or x/y axes with ticks. Child blocks (point, plot) draw on its shared scale. */
+(() => {
+  let seq = 0;
+  const nice = (lo, hi, want) => { const raw = (hi - lo) / want, p = 10 ** Math.floor(Math.log10(raw)), m = raw / p;
+    return (m < 1.5 ? 1 : m < 3 ? 2 : m < 7 ? 5 : 10) * p; };
+  const ticks = (lo, hi, st) => { const out = []; for (let v = Math.ceil(lo / st - 1e-9) * st; v <= hi + 1e-9; v += st) out.push(+v.toFixed(10)); return out; };
+  Rupaka.block('axis', (b, ctx) => {
+    const {el, sv, show} = Rupaka, [x0, x1] = b.x || [-5, 5], line = !b.y, [y0, y1] = b.y || [0, 1];
+    const W = 600, H = line ? 80 : (b.height || 360), L = line ? 16 : 40, Rm = 16, T = line ? 30 : 12, B = line ? 30 : 28;
+    const X = v => L + (v - x0) / (x1 - x0) * (W - L - Rm), Y = v => line ? T : T + (y1 - v) / (y1 - y0) * (H - T - B);
+    const plane = {X, Y, line, W, H, x: [x0, x1], y: [y0, y1], invX: px => x0 + (px - L) / (W - L - Rm) * (x1 - x0), invY: py => y1 - (py - T) / (H - T - B) * (y1 - y0)};
+    const id = `rk-clip-${++seq}`;
+    const svg = sv('svg', {viewBox: `0 0 ${W} ${H}`, role: 'group', 'aria-label': b.label || 'axes'});
+    plane.svg = svg; plane.clip = `url(#${id})`;
+    const g = sv('g', {class: 'grid'});
+    const xs = ticks(x0, x1, b.xstep || nice(x0, x1, 10)), ys = line ? [] : ticks(y0, y1, b.ystep || nice(y0, y1, 8));
+    const ax = line ? T : Y(Math.min(y1, Math.max(y0, 0))), ay = X(Math.min(x1, Math.max(x0, 0)));
+    xs.forEach(v => { g.append(sv('line', {class: v === 0 && !line ? 'zero' : 'hair', x1: X(v), x2: X(v), y1: line ? T - 5 : T, y2: line ? T + 5 : H - B}),
+      sv('text', {class: 'num', x: X(v), y: line ? T + 22 : H - B + 18, 'text-anchor': 'middle', text: show(v, 3)})); });
+    ys.forEach(v => { g.append(sv('line', {class: v === 0 ? 'zero' : 'hair', x1: L, x2: W - Rm, y1: Y(v), y2: Y(v)}),
+      sv('text', {class: 'num', x: L - 6, y: Y(v) + 4, 'text-anchor': 'end', text: show(v, 3)})); });
+    g.append(sv('line', {class: 'main', x1: L, x2: W - Rm, y1: ax, y2: ax}));
+    if (!line) g.append(sv('line', {class: 'main', x1: ay, x2: ay, y1: T, y2: H - B}));
+    if (b.xlabel) g.append(sv('text', {class: 'axl', x: W - Rm, y: line ? T - 10 : ax - 8, 'text-anchor': 'end', text: b.xlabel}));
+    if (b.ylabel && !line) g.append(sv('text', {class: 'axl', x: ay + 8, y: T + 12, text: b.ylabel}));
+    svg.append(sv('defs', {}, sv('clipPath', {id}, sv('rect', {x: L, y: line ? 0 : T, width: W - L - Rm, height: line ? H : H - T - B}))), g);
+    const c2 = Object.assign(Object.create(ctx), {plane});
+    svg.append(...(b.blocks || []).map(k => Rupaka.build(k, c2)));
+    return el('div', {}, Rupaka.label(b), svg);
+  });
+})();

rupaka/blocks/axis/block.json

@@ -0,0 +1,18 @@
+{
+  "name": "axis",
+  "since": "0.0.1",
+  "purpose": "A number line (give only x) or x/y axes with ticks. Put point and plot blocks inside it; they share its scale.",
+  "binds": "none",
+  "keys": "none",
+  "props": {
+    "x": {"type": "range", "req": true, "doc": "[min, max] of x"},
+    "y": {"type": "range", "doc": "[min, max] of y; leave it out for a number line"},
+    "xstep": {"type": "num", "doc": "the tick step on x"},
+    "ystep": {"type": "num", "doc": "the tick step on y"},
+    "xlabel": {"type": "str"},
+    "ylabel": {"type": "str"},
+    "height": {"type": "num", "default": 360},
+    "label": {"type": "str"},
+    "blocks": {"type": "blocks", "req": true, "doc": "point and plot blocks only", "only": ["point", "plot"]}
+  }
+}

rupaka/blocks/axis/example.json

@@ -0,0 +1,12 @@
+{
+  "rupaka": 1, "id": "axis-example", "title": "Axis",
+  "ask": "Place the point where you think −7/3 is. Then lock in.",
+  "state": {"x": 0},
+  "derive": [{"fn": "expr", "expr": "-7/3", "out": "target"}, {"fn": "expr", "expr": "round(target)", "out": "near"}],
+  "blocks": [
+    {"type": "axis", "x": [-4, 4], "xstep": 1, "blocks": [{"type": "point", "bind": "x", "step": 0.25, "label": "you"}]},
+    {"type": "gate", "id": "near", "prompt": "Which whole number is closest to −7/3?", "options": [-3, -2, 2, 3], "answer": "near"},
+    {"type": "axis", "after": "near", "x": [-4, 4], "xstep": 1, "blocks": [{"type": "point", "x": "target", "label": "−7/3"}]},
+    {"type": "caption", "after": "near", "text": "−7/3 is **{target:3}**. Where is −8/3?"}
+  ]
+}

rupaka/blocks/bars/bars.css

@@ -0,0 +1,8 @@
+.rk-bars .bar { transition: transform .25s ease; }
+.rk-bars rect { transition: width .25s ease, x .25s ease; }
+.rk-bars rect.p0, .rk-bars .key i.p0 { fill: var(--rk-acc); background: var(--rk-acc); }
+.rk-bars rect.p1, .rk-bars .key i.p1 { fill: color-mix(in srgb, var(--rk-acc) 50%, var(--rk-bg)); background: color-mix(in srgb, var(--rk-acc) 50%, var(--rk-bg)); }
+.rk-bars text.v { fill: var(--rk-mute); font-size: 13px; font-variant-numeric: tabular-nums; }
+.rk-bars text.t { font-size: 15px; }
+.rk-bars .key { font-size: 13px; color: var(--rk-mute); display: flex; gap: 16px; margin-top: 4px; }
+.rk-bars .key i { display: inline-block; width: 10px; height: 10px; margin-right: 6px; vertical-align: -1px; }

rupaka/blocks/bars/bars.js

@@ -0,0 +1,24 @@
+/* bars: horizontal bars from a derived list of {id, value, parts} or of numbers. Rows keep their element, so a new order slides. */
+Rupaka.block('bars', (b, ctx) => {
+  const {el, sv, show} = Rupaka, H = 30, W = 600, L = b.gutter ?? 48, names = b.items || {};
+  const svg = sv('svg', {role: 'img', 'aria-label': b.label || b.bind}), keyed = {};
+  const key = b.parts ? el('div', {class: 'key'}, b.parts.map((p, i) => el('span', {}, el('i', {class: `p${i ? 1 : 0}`}), p))) : null;
+  const rows = () => (ctx.s.get(b.bind) || []).map((x, i) => typeof x === 'number' ? {id: String(i), value: x} : x);
+  ctx.s.on(() => {
+    const xs = rows(), mx = b.max ?? Math.max(...xs.map(x => x.value), 1e-9), sc = (W - L - 70) / mx;
+    svg.setAttribute('viewBox', `0 0 ${W} ${H * xs.length || H}`);
+    xs.forEach((x, i) => {
+      let g = keyed[x.id];
+      if (!g) { g = keyed[x.id] = sv('g', {class: 'bar'}, sv('text', {class: 't', x: 0, y: H / 2 + 5, text: names[x.id] || x.id}),
+                  sv('rect', {class: 'p0', x: L, y: 7, height: H - 14}), sv('rect', {class: 'p1', y: 7, height: H - 14}), sv('text', {class: 'v', y: H / 2 + 5})); svg.append(g); }
+      g.style.display = '';
+      g.style.transform = `translate(0px, ${i * H}px)`;
+      const [a, c] = x.parts || [x.value, 0], [r0, r1] = g.querySelectorAll('rect'), v = g.querySelector('text.v');
+      r0.style.width = `${Math.max(0, a * sc)}px`; r1.style.x = `${L + a * sc}px`; r1.style.width = `${Math.max(0, c * sc)}px`;
+      v.setAttribute('x', L + Math.max(0, (a + c) * sc) + 6); v.textContent = show(x.value, b.digits ?? 4);
+    });
+    Object.keys(keyed).forEach(id => { if (!xs.some(x => x.id === id)) keyed[id].style.display = 'none'; });
+    svg.setAttribute('aria-label', `${b.label || b.bind}: ${xs.map(x => `${names[x.id] || x.id} ${show(x.value, b.digits ?? 4)}`).join(', ')}`);
+  });
+  return el('div', {}, Rupaka.label(b), svg, key);
+});

rupaka/blocks/bars/block.json

@@ -0,0 +1,16 @@
+{
+  "name": "bars",
+  "since": "0.0.1",
+  "purpose": "Horizontal bars for a derived list of {id, value, parts} (from rrf or softmax) or of numbers. Rows slide to their new place.",
+  "binds": "derived list",
+  "keys": "none",
+  "props": {
+    "bind": {"type": "key", "req": true, "doc": "the state key of the list"},
+    "label": {"type": "str"},
+    "items": {"type": "dict", "doc": "a name to show for each id"},
+    "parts": {"type": "list", "doc": "names of the two stacked parts, for a key under the bars"},
+    "max": {"type": "num", "doc": "a fixed top of the scale, for example 1 for shares"},
+    "digits": {"type": "int", "default": 4},
+    "gutter": {"type": "num", "default": 48, "doc": "the width for the row names"}
+  }
+}

rupaka/blocks/bars/example.json

@@ -0,0 +1,9 @@
+{
+  "rupaka": 1, "id": "bars-example", "title": "Bars",
+  "state": {"logits": [2, 1, 0], "t": 1},
+  "derive": [{"fn": "softmax", "in": "logits", "t": "t", "labels": ["cat", "dog", "fish"], "sort": true, "out": "p"}],
+  "blocks": [
+    {"type": "gate", "id": "top", "prompt": "Which label gets the largest share?", "options": ["cat", "dog", "fish"], "answer": "p.0.id"},
+    {"type": "bars", "after": "top", "bind": "p", "label": "Share", "max": 1, "digits": 3}
+  ]
+}

rupaka/blocks/caption/block.json

@@ -0,0 +1,11 @@
+{
+  "name": "caption",
+  "since": "0.0.1",
+  "purpose": "The explain text after a reveal. End it with one new question that the learner can answer only by using the controls.",
+  "binds": "none",
+  "keys": "none",
+  "props": {
+    "text": {"type": "text", "req": true, "doc": "short text; **bold** and {path} are allowed, nothing else"},
+    "label": {"type": "str", "doc": "a small label above the text"}
+  }
+}

rupaka/blocks/caption/caption.css

@@ -0,0 +1,2 @@
+.rk-caption p { color: var(--rk-ink2); font-size: 16px; margin: 0; }
+.rk-caption b { color: var(--rk-fg); font-weight: 600; }

rupaka/blocks/caption/caption.js

@@ -0,0 +1,6 @@
+/* caption: the explain text. Only **bold** and {path} are special; all text goes in with textContent, so no HTML runs. */
+Rupaka.block('caption', (b, ctx) => {
+  const {el, fmt} = Rupaka, p = el('p');
+  ctx.s.on(() => p.replaceChildren(...String(b.text ?? '').split('**').map((t, i) => i % 2 ? el('b', {text: fmt(t, ctx.s.st)}) : fmt(t, ctx.s.st))));
+  return el('div', {}, Rupaka.label(b), p);
+});

rupaka/blocks/caption/example.json

@@ -0,0 +1,9 @@
+{
+  "rupaka": 1, "id": "caption-example", "title": "Caption",
+  "state": {"n": 4},
+  "derive": [{"fn": "expr", "expr": "n * 2", "out": "twice"}],
+  "blocks": [
+    {"type": "gate", "id": "twice", "prompt": "What is twice {n}?", "options": [6, 8, 16], "answer": "twice"},
+    {"type": "caption", "after": "twice", "text": "Twice {n} is **{twice}**. What is twice that?"}
+  ]
+}

rupaka/blocks/choice/block.json

@@ -0,0 +1,13 @@
+{
+  "name": "choice",
+  "since": "0.0.1",
+  "purpose": "Pick one of a few cases, for example which input to try.",
+  "binds": "string",
+  "keys": "←/→ or A/D move, 1-9 pick",
+  "lockable": true,
+  "props": {
+    "bind": {"type": "key", "req": true, "doc": "the state key of the picked option"},
+    "options": {"type": "list", "req": true, "doc": "the options, two to nine"},
+    "label": {"type": "str"}
+  }
+}

rupaka/blocks/choice/choice.css

@@ -0,0 +1,2 @@
+.rk-choice .opts { display: flex; gap: 8px; flex-wrap: wrap; }
+.rk-choice .opts button[aria-checked=true] { border-color: var(--rk-acc); box-shadow: inset 0 -2px 0 var(--rk-acc); }

rupaka/blocks/choice/choice.js

@@ -0,0 +1,20 @@
+/* choice: a row of options with one picked. ←/→ or A/D move, 1-9 pick. */
+Rupaka.block('choice', (b, ctx) => {
+  const {el, show} = Rupaka, s = ctx.s, os = b.options || [];
+  const box = el('div', {class: 'opts', role: 'radiogroup', 'aria-label': b.label || b.bind});
+  const btns = os.map((o, i) => el('button', {type: 'button', role: 'radio', onclick: () => ctx.put(b, b.bind, o)}, show(o), i < 9 ? el('kbd', {text: i + 1}) : null));
+  box.append(...btns);
+  box.addEventListener('keydown', e => {
+    if (e.metaKey || e.ctrlKey || e.altKey) return;
+    const k = e.key.toLowerCase(), i = os.indexOf(s.get(b.bind));
+    const j = ['arrowright', 'd'].includes(k) ? i + 1 : ['arrowleft', 'a'].includes(k) ? i - 1 : /^[1-9]$/.test(k) ? +k - 1 : null;
+    if (j == null || j < 0 || j >= os.length) return;
+    e.preventDefault();
+    if (ctx.put(b, b.bind, os[j])) btns[j].focus();
+  });
+  s.on(() => {
+    const v = s.get(b.bind), at = Math.max(0, os.indexOf(v));
+    btns.forEach((x, i) => { x.setAttribute('aria-checked', String(os[i] === v)); x.tabIndex = i === at ? 0 : -1; x.disabled = !ctx.live(b.lock); });
+  });
+  return el('div', {}, Rupaka.label(b), box);
+});

rupaka/blocks/choice/example.json

@@ -0,0 +1,11 @@
+{
+  "rupaka": 1, "id": "choice-example", "title": "Choice",
+  "state": {"shape": "square"},
+  "derive": [{"fn": "lookup", "table": "sides", "key": "shape", "out": "n"}],
+  "blocks": [
+    {"type": "choice", "bind": "shape", "label": "Shape", "options": ["triangle", "square", "hexagon"]},
+    {"type": "gate", "id": "n", "prompt": "How many sides has a {shape}?", "options": [3, 4, 6], "answer": "n.sides", "context": "For a {shape}:", "again": true},
+    {"type": "readout", "after": "n", "text": "A {shape} has {n.sides} sides."}
+  ],
+  "tables": {"sides": [{"id": "triangle", "sides": 3}, {"id": "square", "sides": 4}, {"id": "hexagon", "sides": 6}]}
+}

rupaka/blocks/gate/block.json

@@ -0,0 +1,17 @@
+{
+  "name": "gate",
+  "since": "0.0.1",
+  "purpose": "Ask one question and hide the result until the learner locks in a prediction. Blocks with \"after\": this id wait for it.",
+  "binds": "none",
+  "keys": "1-9 pick, ←/→ or A/D move, ⌘↩ lock in",
+  "props": {
+    "id": {"type": "str", "req": true, "doc": "the gate id; other blocks name it in after or lock"},
+    "prompt": {"type": "text", "req": true, "doc": "the question; {path} takes a state value"},
+    "options": {"type": "options", "req": true, "doc": "a list of answers, or {\"from\": path} for a list in the state (for example rules alts)"},
+    "answer": {"type": "answer", "req": true, "doc": "a state path that holds the right answer, or {\"is\": value} for a fixed answer"},
+    "why": {"type": "str", "doc": "a placeholder that asks the learner to say why in one line"},
+    "context": {"type": "text", "doc": "names the inputs the verdict is for, for example \"For {a} + {b}:\"; needed when a live control feeds the answer"},
+    "again": {"type": "bool", "default": false, "doc": "let the learner predict again for new inputs"},
+    "hides": {"type": "keys", "doc": "with a fixed answer: the keys that would give the answer away; blocks that show them must wait"}
+  }
+}

rupaka/blocks/gate/example.json

@@ -0,0 +1,10 @@
+{
+  "rupaka": 1, "id": "gate-example", "title": "Gate",
+  "ask": "Two plus three. Predict the sum before you see it.",
+  "state": {"a": 2, "b": 3},
+  "derive": [{"fn": "expr", "expr": "a + b", "out": "sum"}],
+  "blocks": [
+    {"type": "gate", "id": "sum", "prompt": "What is {a} + {b}?", "options": [4, 5, 6, 23], "answer": "sum", "why": "Say why, in one line."},
+    {"type": "readout", "after": "sum", "label": "The sum", "text": "{a} + {b} = {sum}"}
+  ]
+}

rupaka/blocks/gate/gate.css

@@ -0,0 +1,14 @@
+.rk-gate { padding: 14px 0; border-top: 1px solid var(--rk-line); border-bottom: 1px solid var(--rk-line); }
+.rk-gate .q { margin: 0 0 10px; }
+.rk-gate .opts { display: flex; gap: 8px; flex-wrap: wrap; margin-bottom: 12px; }
+.rk-gate .opts button[aria-checked=true] { border-color: var(--rk-acc); box-shadow: inset 0 -2px 0 var(--rk-acc); }
+.rk-gate .opts button:disabled { opacity: 1; color: var(--rk-ink2); }
+.rk-gate .opts button:disabled[aria-checked=true] { color: var(--rk-fg); }
+.rk-gate textarea { box-sizing: border-box; width: 100%; font: 16px/1.5 var(--rk-serif); color: var(--rk-fg); background: transparent; border: 0;
+                    border-bottom: 1px solid color-mix(in srgb, var(--rk-fg) 22%, transparent); padding: 4px 2px; resize: vertical; margin-bottom: 12px; }
+.rk-gate textarea:focus { outline: none; border-bottom-color: var(--rk-fg); }
+.rk-gate textarea::placeholder { color: var(--rk-mute); font-style: italic; opacity: 1; }
+.rk-gate .verdict { margin: 0 0 10px; font-size: 18px; }
+.rk-gate .verdict .ok { color: var(--rk-ok); } .rk-gate .verdict .no { color: var(--rk-no); }
+.rk-gate .verdict .stale { color: var(--rk-mute); font-size: 15px; font-style: italic; }
+.rk-gate .acts { display: flex; gap: 10px; align-items: center; }

rupaka/blocks/gate/gate.js

@@ -0,0 +1,61 @@
+/* gate: predict, then reveal. Keys 1-9 pick, ←/→ or A/D move, ⌘↩ locks in. Blocks with `after: id` wait for it.
+   The verdict names the inputs it was for (`context`), because the inputs can change after the reveal. */
+Rupaka.block('gate', (b, ctx) => {
+  const {el, fmt, show} = Rupaka, s = ctx.s, id = b.id;
+  s.st.gate[id] = 'open';
+  let picked = null, said = '', seen = '';
+  const opts = () => Array.isArray(b.options) ? b.options : (s.get(b.options.from) || []);
+  const ans = () => b.answer && typeof b.answer === 'object' ? b.answer.is : s.get(b.answer);
+  const done = () => s.get(`gate.${id}`) === 'done';
+  const q = el('p', {class: 'q', id: `rk-${ctx.spec.id || 'd'}-${id}-q`});
+  const box = el('div', {class: 'opts', role: 'radiogroup', 'aria-labelledby': q.id});
+  const why = b.why ? el('textarea', {rows: 1, placeholder: b.why, 'aria-label': b.why}) : null;
+  const go = el('button', {class: 'go', type: 'button', disabled: true}, 'Lock in', el('kbd', {text: '⌘↩'}));
+  const again = el('button', {type: 'button', hidden: true}, 'Try another');
+  const verdict = el('p', {class: 'verdict', 'aria-live': 'polite', hidden: true});
+  const stale = el('span', {class: 'stale', hidden: true, text: ' The demo now shows other inputs.'});
+  const pick = o => { if (done()) return; picked = o; paint(); };
+  function paint() {
+    const os = opts(), k = JSON.stringify(os);
+    if (k !== seen) {
+      seen = k;
+      box.replaceChildren(...os.map((o, i) => el('button', {type: 'button', role: 'radio', onclick: () => pick(o)}, show(o), i < 9 ? el('kbd', {text: i + 1}) : null)));
+    }
+    [...box.children].forEach((x, i) => { x.setAttribute('aria-checked', String(os[i] === picked)); x.disabled = done(); x.tabIndex = os[i] === picked || (picked == null && i === 0) ? 0 : -1; });
+    go.disabled = picked == null || done(); go.hidden = done(); again.hidden = !(done() && b.again); verdict.hidden = !done();
+    stale.hidden = !done() || !b.context || fmt(b.context, s.st) === said;
+  }
+  function commit() {
+    if (picked == null || done()) return false;
+    const a = ans(), ok = String(picked) === String(a);
+    said = b.context ? fmt(b.context, s.st) : '';
+    verdict.replaceChildren(said ? `${said} ` : '', 'You said ', el('b', {class: ok ? 'ok' : 'no', text: show(picked)}), '. ',
+      ok ? el('span', {class: 'ok', text: 'That is right.'}) : el('span', {}, 'It is ', el('b', {class: 'ok', text: show(a)}), '.'), stale);
+    s.st.gate[id] = 'done';
+    const detail = {gate: id, picked, ans: a, ok, why: why ? why.value : '', context: said};
+    s.st.log = [...(s.st.log || []), detail];
+    s.set('_', (s.st._ || 0) + 1);
+    Rupaka.predict(ctx, detail);
+    return true;
+  }
+  go.onclick = commit;
+  again.onclick = () => { picked = null; said = ''; if (why) why.value = ''; s.st.gate[id] = 'open'; s.set('_', (s.st._ || 0) + 1); box.querySelector('button')?.focus(); };
+  (ctx.gates ||= []).push({id, commit, done});
+  ctx.commit ||= () => { const g = ctx.gates.find(g => !g.done()); return g ? g.commit() : false; };
+  const root = el('div', {}, q, box, why, verdict, el('div', {class: 'acts'}, go, again));
+  root.addEventListener('keydown', e => {
+    if (e.target.tagName === 'TEXTAREA' || done() || e.metaKey || e.ctrlKey || e.altKey) return;
+    const os = opts(), k = e.key.toLowerCase(), i = os.indexOf(picked);
+    let j = /^[1-9]$/.test(k) ? +k - 1 : null;
+    if (j == null && e.target.closest('.opts')) j = ['arrowright', 'arrowdown', 'd'].includes(k) ? i + 1 : ['arrowleft', 'arrowup', 'a'].includes(k) ? Math.max(0, i - 1) : null;
+    if (j == null || j < 0 || j >= os.length) return;
+    e.preventDefault(); pick(os[j]);
+    if (e.target.closest('.opts')) box.children[j].focus();
+  });
+  s.on(() => {
+    q.textContent = fmt(b.prompt, s.st);
+    if (!Array.isArray(b.options) && !done() && !opts().some(o => o === picked)) picked = null;
+    paint();
+  });
+  return root;
+});

rupaka/blocks/grid/block.json

@@ -0,0 +1,23 @@
+{
+  "name": "grid",
+  "since": "0.0.1",
+  "purpose": "A heatmap of a list of numbers or a list of rows (logits, weights). The learner can raise or lower a cell.",
+  "binds": "list of numbers or list of rows",
+  "keys": "arrows or WASD move, + or E raise, − or Q lower, ⇧ for ten steps",
+  "lockable": true,
+  "props": {
+    "bind": {"type": "key", "req": true, "doc": "the state key of the numbers"},
+    "rows": {"type": "list", "doc": "row names"},
+    "cols": {"type": "list", "doc": "column names"},
+    "step": {"type": "num", "default": 1},
+    "min": {"type": "num"},
+    "max": {"type": "num"},
+    "lo": {"type": "num", "doc": "the value at the pale end of the ramp; the smallest value if left out"},
+    "hi": {"type": "num", "doc": "the value at the dark end of the ramp; the largest value if left out"},
+    "digits": {"type": "int", "default": 2},
+    "cell": {"type": "num", "default": 64, "doc": "the cell width"},
+    "gutter": {"type": "num", "default": 70, "doc": "the width for the row names"},
+    "note": {"type": "str"},
+    "label": {"type": "str"}
+  }
+}