Adds hs-host-to-sx to convert raw host-handle JS objects/arrays returned by
json-parse or io-fetch into proper SX dicts/lists. hs-fetch now calls it on
the result when format is "json". Detects host handles via absence of the
internal `_type` marker, then walks Object.keys / Array items recursively.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
String global with fromCharCode (variadic). parseInt truncates via
js-math-trunc; parseFloat delegates to js-to-number. Wired into
js-global.
381/383 unit (+5), 148/148 slice unchanged.
40 clusters across 6 buckets. Bucket E is human-only (WebSocket,
Tokenizer-API, SourceInfo, WebWorker, fetch non-2xx). Agent loop
works A→B→C→D→F serially, one cluster per commit, aborts on
regression.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Parser: jp-parse-postfix emits (js-postfix op target) on trailing
++/--; jp-parse-primary emits (js-prefix op target) before the
unary -/+/!/~ branch.
Transpile: js-transpile-prefix → (set! name (+ (js-to-number name)
±1)) for idents, (js-set-prop obj key ...) for members/indices.
js-transpile-postfix caches old value in a let binding, updates,
returns the saved value.
340/342 unit (+11), 148/148 slice unchanged.
Math gains sqrt/pow/trunc/sign/cbrt/hypot plus LN2/LN10/LOG2E/
LOG10E/SQRT2/SQRT1_2 constants and full-precision PI/E.
Number global: isFinite/isNaN/isInteger/isSafeInteger plus
MAX_VALUE/MIN_VALUE/MAX_SAFE_INTEGER/MIN_SAFE_INTEGER/EPSILON/
POSITIVE_INFINITY/NEGATIVE_INFINITY/NaN.
Global isFinite, isNaN, Infinity, NaN. Wired into js-global.
329/331 unit (+21), 148/148 slice unchanged.
- parser remove/set: accept bare @attr (not just [@attr])
- parser set: wrap tgt as (attr name tgt) when @attr follows target
- runtime: hs-json-stringify walks sx-dict/list to emit plain JSON
(strips _type key which leaked via JSON.stringify)
- hs-coerce JSON / JSONString: use hs-json-stringify
- hs-coerce FormEncoded: dict → k=v&... (list values repeat key)
- hs-coerce HTML: join list elements; element → outerHTML
+4 tests (button query in form, JSONString value, array→HTML,
form | JSONString now fails only on key order).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
- runtime hs-add-to!/hs-append: dedupe on list targets (Set semantics)
- compiler emit-set: set result to X now syncs it too
- compiler append!: handle (local)/(ref) targets via emit-set so scoped
vars get rebound to the returned list
- parser add/remove: accept bare @attr (not just [@attr])
- parser add-attr: support when-clause → emits add-attr-when
- compiler add-class-when/add-attr-when: collect matched items into
the-result / it so subsequent "if the result is empty" works
+6 upstream tests in early range (add 13→17, append 10→12).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Initial commit of the lib/js/ tree and plans/ directory. A previous
session left template-string work in progress — 278/280 unit tests pass
(2 failing: tpl part-count off-by-one, escaped-backtick ident lookup).
test262-runner.py and scoreboard are placeholders (0/8 with 7 timeouts);
fixing the runner is the next queue item.
- parse-atom: 'you' and 'yourself' keywords resolve to (ref <name>) so
they look up the let-binding the tell-command installs.
- 'your <prop>' no longer aliases 'my <prop>' — it's the possessive over
the 'you' binding, mirroring 'its' over 'it'.
Unblocks 'you symbol represents the thing being told' and 'can take a class
and swap it with another via with' (via you/your in tell handlers). Net:
tell 6→7 (was 6/10).
Upstream body helpers often call element methods directly — showModal,
close, focus, blur, reset, remove. Emit dom-dispatch or host-call ops so
tests that rely on these pre-click state changes work.
Net: dialog 9→12 (100%).
- parse-trigger-cmd: use parse-compound-event-name so 'trigger foo:bar' and
'trigger foo.bar' preserve the full event name. Also parse an optional
detail dict '(x:42)' like parse-send-cmd.
- compiler: 3-arg (trigger NAME DETAIL TGT) emits dom-dispatch with the
detail dict. 2-arg (trigger NAME TGT) unchanged.
- emit-on event-ref bindings now use (host-get event 'detail') → the event
carries detail as a JS object, so the SX 'get' primitive returned nil
and tests checking 'on foo(x) … x' saw empty values.
Net: trigger 2→6 (100%).
Mock DOM:
- El now tracks defaultValue/defaultChecked/defaultSelected and a reset()
method that walks descendant form controls, restoring them.
- setAttribute(value|checked|selected) sets the matching default-* too, so
the initial HTML state can be restored later.
- parseHTMLFragments + _setInnerHTML capture a textarea's textContent as
its value AND defaultValue.
Generator (pw-body):
- add_action / add_assertion extract .first() / .last() / .nth(N) modifiers
into (nth (dom-query-all …) i) or a (let ((_all …)) (nth _all (- … 1)))
tail so multi-match helpers hit the right element.
Compiler:
- emit-reset! with a .<class>/.<sel> query target now compiles to hs-query-all
so 'reset .resettable' resets every matching control (not just the first).
Net: reset 1→8 (100%).
- hs-pick-first/last/random/items/slice: short-circuit nil or non-list
(strings flow through unchanged).
- New hs-pick-match / hs-pick-matches wrappers around regex-match /
regex-find-all, also nil-safe; compiler routes pick-match / pick-matches
through them. Unblocks 'pick first from null returns null' and
'pick match from null returns null' which previously looped past
step_limit.
Upstream tests use clickAndReadStyle(evaluate, sel, prop) to click-and-read
before asserting toHaveCSS(sel, prop, val). Emit just the click — downstream
toHaveCSS checks then test the post-click state. Net: transition 6→13.
'add .foo to my children' compiles to (dom-add-class (host-get me 'children') 'foo') where
children is a list. Fanned out via for-each inside dom-add-class/dom-remove-class rather
than calling .classList.add on the list itself. Net: add 10→13.
- tokenizer: add 'giving' as keyword so parse-take-cmd can detect it.
- parser.sx parse-take-cmd: loop over 'with <class>' / 'giving <class>' /
'from <sel>' / 'for <tgt>' clauses in any order for both the class and
attribute cases. Emits uniform (take! kind name from-sel for-tgt
attr-val with-val) 7-slot AST.
- compiler emit-take: pass with-cls for the class case through to runtime.
- runtime hs-take!: with a class 'with' replacement, toggle both classes
across scope + target. For attribute take, always strip the attr from
the scope 'others' (setting to with-val if given, otherwise removing).
- generator pw-body: translate evaluate(() => document.querySelector(s).
click()) and .dispatchEvent(new Event('name', …)) into dom-dispatch ops
so bubbling-click assertions in 'parent takes…' tests work.
- generator toHaveClass: strip JS regex word-boundaries (\\b) from the
expected class name.
- shared/static/wasm/sx/dom.sx: dom-child-list / dom-child-nodes mirror
the dom-query-all SX-list passthrough — childNodes arrives pre-SXified.
Net: take 6→15 (100%), remove 16→17, fetch 11→15.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
- generate-sx-tests.py: add_action/add_assertion accept .nth(N) in PW-body
tests so 'find(sel).nth(1).dispatchEvent(...)' lands as a dispatch on
the Nth matching element, and assertions target that same element.
- shared/static/wasm/sx/dom.sx: dom-query-all hands through an already-SX
list unchanged — the bridge often pre-converts NodeLists/arrays to SX
lists, so the host-get 'length' / host-call 'item' loop was returning
empty. Guards node-list=nil and non-list types too.
- tests/hs-run-filtered.js (mock DOM): fnd() understands
':nth-of-type(N)', ':first-of-type', ':last-of-type' by matching the
stripped base selector and returning the correct-indexed sibling.
Covers upstream tests that write 'find("div:nth-of-type(2)")' to
pick the HS-owning element.
- Runtime runtime.sx: hs-sorted-by, hs-fetch format normalizer (JSON/
Object/etc.), nil-safe hs-joined-by/hs-split-by, emit-fetch chain sets
the-result when wrapped in let((it …)).
Net: take 0→6, hide 11→12, show 15→16, fetch 11→15,
collectionExpressions 13→15 (remaining are a WASM JIT bug on
{…} literals inside arrays).
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Runtime (lib/hyperscript/ + shared/static/wasm/sx/hs-*.sx):
- make: parser accepts `<tag.class#id/>` selectors and `from <expr>,…`; compiler
emits via scoped-set so `called <name>` persists; `called $X` lands on
window; runtime dispatches element vs host-new constructor by type.
- Values: `x as Values` walks form inputs/selects/textareas, producing
{name: value | [value,…]}; duplicates promote to array; multi-select and
checkbox/radio handled.
- toggle *display/*visibility/*opacity: paired with sensible inline defaults
in the mock DOM so toggle flips block/visible/1 ↔ none/hidden/0.
- add/remove/put at array: emit-set paths route list mutations back through
the scoped binding; add hs-put-at! / hs-splice-at! / hs-dict-without.
- remove OBJ.KEY / KEY of OBJ: rebuild dict via hs-dict-without and reassign,
since SX dicts are copy-on-read across the bridge.
- dom-set-data: use (host-new "Object") rather than (dict) so element-local
storage actually persists between reads.
- fetch: hs-fetch normalizes JSON/Object/Text/Response format aliases;
compiler sets `the-result` when wrapping a fetch in the `let ((it …))`
chain, and __get-cmd shares one evaluation via __hs-g.
Mock DOM (tests/hs-run-filtered.js):
- parseHTMLFragments accepts void elements (<input>, <br>, …);
- setAttribute tracks name/type/checked/selected/multiple;
- select.options populated on appendChild;
- insertAdjacentHTML parses fragments and inserts real El children into the
parent so HS-activated handlers attach.
Generator (tests/playwright/generate-sx-tests.py):
- process_hs_val strips `//` / `--` line comments before newline→then
collapse, and strips spurious `then` before else/end/catch/finally.
- parse_dev_body interleaves window-setup ops and DOM resets between
actions/assertions; pre-html setups still emit up front.
- generate_test_pw compiles any `<script type=text/hyperscript>` (flattened
across JS string-concat) under guard, exposing def blocks.
- Ordered ops for `run()`-style tests check window.obj.prop via new
_js_window_expr_to_sx; add DOM-constructing evaluate + _hyperscript
pattern for `as Values` tests (result.key[i].toBe(…)).
- js_val_to_sx handles backticks and escapes embedded quotes.
Net delta across suites:
- if 16→18, make 0→8, toggle 12→21, add 9→10, remove 11→16, put 29→31,
fetch 11→15, repeat 14→26, expressions/asExpression 20→25, set 27→28,
core/scoping 12→14, when 39→39 (no regression).
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
process_hs_val replaces newlines with `then` to give the HS parser a
statement separator, but `else then` and `catch foo then` are syntax
errors — `else` and `catch <name>` already open new blocks. Strip the
inserted `then` after them so multi-line if/try parses cleanly.
No net pass-count delta on smoke-tested suites (the if-with-window-state
tests fail for a separate reason: window setups all run before any click
rather than being interleaved with state changes), but the source now
parses correctly and matches what upstream HS sees.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Three related changes for the `evaluate(() => window.X = Y)` setup pattern:
1. extract_window_setups now also matches the single-expression form
`evaluate(() => window.X = Y)` (no braces), in addition to the
block form `evaluate(() => { window.X = Y; ... })`.
2. js_expr_to_sx now recognises `function(args) { return X; }` (and
`function(args) { X; }`) in addition to arrow functions, so e.g.
`window.select2 = function(){ return "select2"; }` translates to
`(fn () "select2")`.
3. generate_test_chai / generate_test_pw (HTML+click test generators)
inject `(host-set! (host-global "window") "X" <sx>)` for each window
setup found in the test body, so HS code that reads `window.X` sees
the right value at activation time.
4. Test-helper preamble now defines `window` and `document` as
`(host-global "window")` / `(host-global "document")`, so HS
expressions like `window.tmp` resolve through the host instead of
erroring on an unbound `window` symbol.
Net effect on suites smoke-tested: nominal, because most affected tests
hit a separate `if/then/else` parser bug — the `then` keyword inserter
in process_hs_val turns multi-line if blocks into ones the HS parser
collapses to "always run the body". Fixing that is the next iteration.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Pattern 2's `parse_run_locals` only looked for `, {locals: {...}}`. Tests
that pass `me:` directly (e.g. `run("my foo", { me: { foo: "foo" } })`)
got an empty locals list, so `my foo` lost its receiver and returned
nothing. Now `me:` (object/array/string/number literal) is also bound
as a local on top of any `locals: {}`.
possessiveExpression 18/23 → 19/23 ("can access my properties").
"can access its properties" still fails because the upstream test passes
`result:` rather than `it:` — appears to be an upstream typo we'd need
the runtime to special-case to fix.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Two related Pattern 1 bugs:
1. The locals capture used `\\{([^}]+)\\}` (greedy non-`}` chars), so
`locals: { that: [1, 2, 3] }` truncated at the first `,` inside `[...]`
and bound `that` to `"[1"`. Switched to balanced-brace extraction +
`split_top_level` so nested arrays/objects survive.
2. `{ me: <X> }` was only forwarded to the SX runtime when X was a single
integer (eval-hs-with-me only accepts numbers). For `me: [1, 2, 3]`
or `me: 1` alongside other locals, `me` was silently dropped, so
`I contain that` couldn't see its receiver. Now any non-numeric `me`
value is bound as a local (`(list (quote me) <val>)`); a numeric
`me` alongside other locals/setups is also bound, so the HS expr
always sees its `me`.
comparisonOperator 79/83 → 81/83 (+2: contains/includes works with arrays).
bind unchanged (43/44).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Last commit's `hs-type-check` rewrite collapsed predicate and assertion
into one runtime fn that always raised on mismatch. That fixed `: Type`
but broke `is a Type` / `is not a Type` (which need a bool):
null is a String expected true, got nil (raised)
null is not a String expected false, got true (default boolean)
Restored the split. Parser now emits `(type-assert ...)` for `:` and
keeps `(type-check ...)` for `is a` / `is not a`. Runtime adds:
- `hs-type-check` — predicate, never raises (nil passes)
- `hs-type-check-strict` — predicate, false on nil
- `hs-type-assert` — value or raises
- `hs-type-assert-strict` — value or raises (also raises on nil)
Compiler maps `type-assert` / `type-assert-strict` to the new runtime fns.
comparisonOperator 74/83 → 79/83 (+5: `is a/an`, `is not a/an` four tests
plus a fifth that depended on them). typecheck stays 2/5 (no regression).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
`set element x to 10` was compiling to `(set! (string-postfix (ref "element") "x") 10)`
because parse-expr greedily consumed `element x` as a string-postfix expression.
Recognise the bare `element` / `global` / `local` ident at the start of the
set target and skip it so `tgt` parses as just `x`. The variable lives in
the closure scope of the handler — close enough for handler-local use; a
real per-element store would need extra work in the compiler.
core/scoping: 9/20 → 12/20 (+3): "element scoped variables work",
"element scoped variables span features", "global scoped variables work".
The `:x` / `$x` short-syntax variants still fail because their listeners
aren't registering in the test mock — separate issue.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Pattern 2 was binding all `expect(result)` assertions in a body to the
*first* `run()`, even when the body re-assigned `result` between checks:
let result = await run("'10' as Float") expect(result).toBe(10)
result = await run("'10.4' as Float") expect(result).toBe(10.4)
Both assertions ran against `'10' as Float`, so half failed. Now the
generator walks `run()` calls in order, parses per-call `{locals: {...}}`
opts (balanced-brace, with the closing `\)` anchoring the lazy quote
match), and pairs each `expect(result)` with the most recent preceding
run.
asExpression 15/42 → 19/42 (+4: as Float / Number / String / Fixed sub-
assertions now check the right expression). Other suites unchanged.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
`'foo' : String` and `'foo' : String!` were returning `true` because
`hs-type-check` was a predicate. Per upstream hyperscript semantics,
`value : Type` is a type-asserted pass-through:
- nil passes the basic check (use `Type!` for non-null)
- mismatched type → raise "Typecheck failed!"
- match → return the original value
`hs-type-check-strict` now also raises on nil rather than returning
false, so the `String!` form actually rejects null.
hs-upstream-expressions/typecheck: 0/5 → 2/5.
asExpression unchanged (uses different `as Type` runtime path).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Parser (lib/hyperscript/parser.sx):
- parse-poss case for "(" (function call) was building (call ...) and
returning without recursing, so `f().x` lost the `.x` suffix and the
compiler emitted (let ((it (f))) (hs-query-first ".x")). Now it tail-
calls parse-poss on the constructed call so chains like f().x.y(),
obj.method().prop, etc. parse correctly.
Generator (tests/playwright/generate-sx-tests.py):
- New js_expr_to_sx: translates arrow functions ((args) => body), object
literals, simple property access / method calls / arith. Falls back
through js_val_to_sx for primitives.
- New extract_window_setups: scans `evaluate(() => { window.X = Y })`
blocks (with balanced-brace inner-body extraction) and returns
(name, sx_value) pairs.
- Pattern 1 / Pattern 2 in generate_eval_only_test merge those window
setups into the locals passed to eval-hs-locals, so HS expressions
can reference globals defined by the test prelude.
- Object literal value parsing now goes through js_expr_to_sx first,
so `{x: x, y: y}` yields `{:x x :y y}` (was `{:x "x" :y "y"}`).
Net: hs-upstream-expressions/functionCalls 0/12 → 5/12 (+5).
Smoke-checked put/set/scoping/possessiveExpression — no regressions.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Wraps `node tests/hs-run-filtered.js` so the agent can run/filter/kill
test runs without per-call Bash permission prompts. Tools:
- hs_test_run: run the suite (optional suite filter, start/end range,
step_limit, verbose); enforces a wall-clock timeout via SIGTERM/SIGKILL
on the child process group, so a hung CEK loop can't strand the agent.
- hs_test_kill: SIGTERM/SIGKILL any background runner.
- hs_test_regen: regenerate spec/tests/test-hyperscript-behavioral.sx.
- hs_test_status: list any in-flight runners.
Stdio JSON-RPC, same protocol as tools/mcp_services.py.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Generator changes (tests/playwright/generate-sx-tests.py):
- toHaveCSS regex: balance parens so `'rgb(255, 0, 0)'` is captured intact
(was truncating at first `)`)
- Map browser-computed colors `rgb(R,G,B)` back to CSS keywords
(red/green/blue/black/white) — our DOM mock returns the inline value
- js_val_to_sx now handles object literals `{a: 1, b: {c: 2}}` → `{:a 1 :b {:c 2}}`
- Pattern 2 (`var x = await run(...)`) now captures locals via balanced-brace
scan and emits `eval-hs-locals` instead of `eval-hs`
- Pattern 1 with locals: emit `eval-hs-locals` (was wrapping in `let`, which
doesn't reach the inner HS env)
- Stop collapsing `\"` → `"` in raw HTML (line 218): the backslash escapes
are legitimate in single-quoted `_='...'` HS attribute values containing
nested HS scripts
Test-framework changes (regenerated into spec/tests/test-hyperscript-behavioral.sx):
- `_hs-wrap-body`: returns expression value if non-nil, else `it`. Lets bare
expressions (`foo.foo`) and `it`-mutating scripts (`pick first 3 of arr;
set $test to it`) both round-trip through the same wrapper
- `eval-hs-locals` now injects locals via `(let ((name (quote val)) ...) sx)`
rather than `apply handler (cons nil vals)` — works around a JIT loop on
some compiled forms (e.g. `bar.doh of foo` with undefined `bar`)
Also synced lib/hyperscript/*.sx → shared/static/wasm/sx/hs-*.sx (the WASM
test runner reads from the wasm/sx/ copies).
Net per-cluster pass counts (vs prior baseline):
- put: 23 → 29 (+6)
- set: 21 → 28 (+7)
- show: 7 → 15 (+8)
- expressions/propertyAccess: 3 → 9 (+6)
- expressions/possessiveExpression: 17 → 18 (+1)
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Several upstream regex-pick tests use JS ES6 shorthand to pass a
local declared earlier in the test body, e.g.
const haystack = "..."
await run(\`pick match of "\\\\d+" from haystack ...\`, {locals: {haystack}});
The generator's `(\\w+)\\s*:\\s*...` locals regex only matched explicit
`key: value` entries, so `{haystack}` produced zero local_pairs and the
HS script failed with "Undefined symbol: haystack". Now a second pass
scans for bare identifiers in the locals object and resolves each
against a preceding `const NAME = VALUE;` in the test body.
Net test-count is unchanged (the affected regex tests still fail — now
with TIMEOUT in the regex engine rather than Undefined-symbol, so this
just moves them closer to real coverage).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Tests using `run("expr", {locals: {x}})` were being translated to SX like
(let ((x val)) (eval-hs "expr") (assert= it EXPECTED))
That never worked: `it` is bound inside eval-hs's handler closure, not in
the outer SX scope, so the assertion errored "Undefined symbol: it".
Meanwhile `x` (bound by the outer let) wasn't reachable from the
eval-expr-cek'd handler either, so any script referencing `x` resolved
via global lookup — silently yielding stale values from earlier tests.
New `eval-hs-locals` helper injects locals as fn parameters of the
handler wrapper:
(fn (me arr str ...) (let ((it nil) (event nil)) <compiled-hs> it))
It's applied with the caller's values, returning the final `it`. The
generator now emits `(assert= (eval-hs-locals "..." (list ...)) EXP)`
for all four expect() patterns when locals are present.
New baseline: 1,055 / 1,496 pass (70.5%, up from 1,022 / 1,496 = 68.3%).
29 additional tests now pass — mostly `pick` (where locals are the
vehicle for passing arr/str test fixtures) plus cascades in
comparisonOperator, asExpression, mathOperator, etc.
Note: the remaining `pick` wins in this batch also depend on local
edits to lib/hyperscript/parser.sx and compiler.sx (not included here;
they're intertwined with pre-existing in-flight HS runtime work).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
The Pattern 1c emitter wrote `;; TODO: assert= ... against {...}` for
object-literal .toEqual() assertions it couldn't translate. It only
.strip()'d the literal, leaving internal newlines intact — so a
multi-line `{...}` leaked SX-invalid text onto subsequent lines and
broke the parse for the rest of the suite.
Collapse all whitespace inside the literal so the `;;` prefix covers the
whole comment.
After regenerating, 1,022/1,496 pass (was 1,013/1,496 with a hand-
patched behavioral.sx). No runtime changes.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
- scrape-hs-upstream.py: new scraper walks /tmp/hs-upstream/test/**/*.js
and emits body-style records for all 1,496 v0.9.90 tests (up from 831).
Widens coverage into 66 previously-missing categories — templates,
reactivity, behavior, worker, classRef, make, throw, htmx, tailwind,
viewTransition, and more.
- build-hs-manifest.py + hyperscript-upstream-manifest.{json,md}:
coverage manifest tagging each upstream test with a status
(runnable / skip-listed / untranslated / missing) and block reason.
- generate-sx-tests.py: emit (error "SKIP (...)") instead of silent
(hs-cleanup!) no-op for both skip-listed tests and generator-
untranslatable bodies. Stub counter now reports both buckets.
- hyperscript-feature-audit-0.9.90.md: gap audit against the 0.9.90
spec; pre-0.9.90.json backs up prior 831-test snapshot.
New honest baseline (ocaml runner, test-hyperscript-behavioral):
831 -> 1,496 tests; 645 -> 1,013 passing (67.7% conformance).
483 failures split: 45 skip-list, 151 untranslated, 287 real.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
- parser `empty` no-target → (ref "me") (was bogus (sym "me"))
- parser `halt` modes distinguish: "all"/"bubbling"/"default" halt execution
(raise hs-return), "the-event"/"the event's" only stop propagation/default.
"'s" now matched as op token, not keyword.
- parser `get` cmd: dispatch + cmd-kw list + parse-get-cmd (parses expr with
optional `as TYPE`). Required for `get result as JSON` in fetch chains.
- compiler empty-target for (local X): emit (set! X (hs-empty-like X)) so
arrays/sets/maps clear the variable, not call DOM empty on the value.
- runtime hs-empty-like: container-of-same-type empty value.
- runtime hs-empty-target!: drop dead FORM branch that was short-circuiting
to innerHTML=""; the querySelectorAll-over-inputs branch now runs.
- runtime hs-halt!: take ev param (was free `event` lookup); raise hs-return
to stop execution unless mode is "the-event".
- runtime hs-reset!: type-aware — FORM → reset, INPUT/TEXTAREA → value/checked
from defaults, SELECT → defaultSelected option.
- runtime hs-open!/hs-close!: toggle `open` attribute on details elements
(not just the prop) so dom-has-attr? assertions work.
- runtime hs-coerce JSON: json-stringify dict/list (was str).
- test-runner mock: host-get on List + "length"/"size" (was only Dict);
dom-set-attr tracks defaultChecked / defaultSelected / defaultValue;
mock_query_all supports comma-separated selector groups.
- generator: emit boolean attrs (checked/selected/etc) even with null value;
drop overcautious "skip HS with bare quotes or embedded HTML" guard so
morph tests (source contains embedded <div>) emit properly.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
The pick tests were referencing an unbound 'it' in the outer test scope
(the upstream JS variant set window.$test then read it from the browser;
the SX variant has no equivalent). Switch each test to assert against the
return value of eval-hs, which already yields the picked value.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
