Re-applied from worktree-agent-a7c6dca2be5bbada0 (commit c4241d57)
onto HEAD that already has clusters 30, 26, 27 runtime changes —
straight cherry-pick conflicted on the cluster-30 log-all block
and cluster-27 intersection helper, so the logical diff was
replayed surgically.
Parser (parse-atom object-literal):
- obj-collect now `append`s pairs in source order instead of
`cons`'ing, so `{foo:1, bar:2, baz:3}` reaches hs-make-object
as `((foo 1) (bar 2) (baz 3))`.
Compiler (emit-for, array-index emission):
- emit-for detects `for x in COLL where COND` (parser wraps COLL
as `(coll-where INNER COND)`) and rewrites the filter lambda
to bind the for-loop variable name rather than the default
`it`, so `where x.val > 10` sees the right binding. Also
unwraps `coll-where` so filter targets the real inner coll.
- emit-for now wraps a symbol collection with `cek-try` (not the
broken `hs-safe-call`, which has an uninitialised CEK call-ref
in the WASM build) so `for prop in x` after `set x to {…}`
iterates x's keys instead of nil.
- array-index emits `(hs-index obj key)` instead of
`(nth obj key)`, which only worked on lists.
Runtime:
- New polymorphic `hs-index` dispatches to get / nth / host-get
based on target type (dict / list / string / otherwise).
- `hs-put-at!` default branch now detects DOM elements via
`hs-element?` and delegates to `hs-put!`, so `put X at end of
elt` on a DOM node appends innerHTML instead of crashing.
- `hs-make-object` tracks insertion order in a hidden `_order`
list; `hs-for-each` and `hs-coerce` (Keys / Entries / Map
branches) prefer `_order` when present, filtering the marker
out of output.
Suite hs-upstream-repeat: 25/30 → 28/30 (+3).
Smoke 0-195 unchanged at 165/195.
Applied from worktree-agent-ad6e17cbc4ea0c94b (commit 0a0fe314)
with manual re-apply onto post-cluster-26 HEAD:
- Parser: parse-on-feat collects `having margin X threshold Y`
clauses between `from X` and the body; packs them into a
`:having {"margin" M "threshold" T}` dict on the parts list.
- Compiler: scan-on threads a new `having-info` parameter through
all recursions; when event-name is "intersection", wraps the
hs-on call with `(do on-call (hs-on-intersection-attach! target
margin threshold))`.
- Runtime: hs-on-intersection-attach! constructs an
IntersectionObserver with {rootMargin, threshold} options and a
callback that dispatches an "intersection" DOM event carrying
{intersecting, entry} detail.
- Runner: HsIntersectionObserver mock fires the callback
synchronously on observe() with isIntersecting=true so handlers
run during activation; ignores margin/threshold (tests assert
only that the handler fires).
Suite hs-upstream-on: 33/70 -> 36/70 (on intersection: 0/3 -> 3/3).
Smoke 0-195 unchanged at 165/195.
Cluster 26. Three parts:
(a) `tests/hs-run-filtered.js`: mock style is now a Proxy that dispatches
a synthetic `resize` DOM event on the owning element whenever
`width` / `height` changes (via `setProperty` or direct assignment).
Detail carries numeric `width` / `height` parsed from the current
inline style. Strengthens the old no-op ResizeObserver stub into an
`HsResizeObserver` class with a per-element callback registry
(collision-proof name vs. cluster 27's IntersectionObserver); HS's
`on resize` uses the plain DOM event path, not the observer API.
Adds `ResizeObserverEntry` for code that references it.
(b) `tests/playwright/generate-sx-tests.py`: new pattern for
`(page.)?evaluate(() => [{] document.{getElementById|querySelector}(…).style.PROP = 'VAL'; [}])`
emitting `(host-set! (host-get target "style") "PROP" "VAL")`.
(c) `spec/tests/test-hyperscript-behavioral.sx`: regenerated — the three
resize fixtures now carry the style mutation step between activate
and assert.
No parser/compiler/runtime changes: `on resize` already parses via
`parse-compound-event-name`, and `hs-on` binds via `dom-listen` which is
plain `addEventListener("resize", …)`.
Suite hs-upstream-resize: 0/3 → 3/3. Smoke 0-195: 164/195 → 165/195
(the +1 smoke bump is logAll-generator work uncommitted in the main tree
at verification time, unrelated to this cluster).
Add `_hs-config-log-all` runtime flag + captured log list. When set
via `hs-set-log-all!`, `hs-activate!` pushes "hyperscript:init" onto
`_hs-log-captured` and mirrors to console.log. Covers cluster 30.
Generator side: eval-only path now detects the logAll body pattern
(`_hyperscript.config.logAll = true`) and emits a deftest that:
- resets captured list
- toggles log-all on
- builds a div with `_="on click add .foo"` and `hs-boot-subtree!`s
- asserts `(some string-contains? "hyperscript:")` over captured logs.
hs-upstream-core/bootstrap: 19/26 -> 20/26. Smoke 0-195: 164 -> 165.
Mirrors the existing Error/TypeError/RangeError/SyntaxError/ReferenceError
shims. Each sets .message and .name on the new object. Unblocks tests
that use these error types in type-check assertions.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Several tests check 'new Function("return 1")' — we can't actually
implement that (would need runtime JS eval). Now Function is a dict with
__callable__ that throws TypeError, and a prototype containing call/apply/
bind/toString/length/name stubs so code that probes Function.prototype
doesn't crash with 'Undefined symbol: Function'.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
process_hs_val stripped `//…` line comments with a naïve regex,
which devoured `https://yyy.xxxxxx.com/…` inside a backtick template
— the 'properly interpolates values 2' fixture was landing with
the HS source truncated at `https:`.
New helper _strip_hs_line_comments walks char-by-char and only
strips `//` / leading-whitespace `--` when not inside `'…'`, `"…"`,
or backticks; respects `\\`-escapes inside strings.
Suite hs-upstream-core/regressions: 11/16 → 12/16.
Smoke 0-195: 163/195 → 164/195.
JS 'globalThis' now rewrites to SX (js-global) — the global object dict.
JS 'eval' rewrites to js-global-eval, a no-op stub that echoes its first
arg. Many test262 tests probe eval's existence or pass simple literals
through it; a no-op is better than 'Undefined symbol: eval'.
A full eval would require plumbing js-eval into the runtime with access
to the enclosing lexical scope — non-trivial. The stub unblocks tests
that just need eval to be callable.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
String.prototype.toUpperCase.hasOwnProperty('length') was failing with
'TypeError: hasOwnProperty is not a function' because js-invoke-method's
dict-with-builtin fallback only matched 'dict' receivers, not functions.
New js-invoke-function-objproto branch handles hasOwnProperty (checks
name/length/prototype keys), toString, valueOf, isPrototypeOf,
propertyIsEnumerable, toLocaleString. Fires from js-invoke-method when
recv is js-function? and key is in the Object.prototype builtin set.
Unblocks many String.prototype tests that check
.hasOwnProperty('length') on the prototype methods.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
parse-trav recognises `parent` as an ident modifier after the
`closest` keyword — consumes it and re-invokes with kind
`closest-parent`, producing AST `(closest-parent "div" (me))` instead
of the generic trailing-ident-as-unit shape
`(string-postfix (closest "*" (me)) "parent")`.
Compiler translates `(closest-parent sel target)` to
`(dom-closest (host-get target "parentElement") sel)` so `me` is
skipped and only strict ancestors match. `closest-parent` also
joined the `put X into <trav>` inner-html shortcut alongside
next/previous/closest.
Suite hs-upstream-core/regressions: 10/16 → 11/16.
Smoke 0-195: 162/195 → 163/195.
Before, Object.prototype was {} — tests writing
Object.prototype.hasOwnProperty.call(o, 'x') failed with 'TypeError: call
is not a function' because hasOwnProperty was undefined on the prototype.
Now Object.prototype.hasOwnProperty / .isPrototypeOf / .propertyIsEnumerable
/ .toString / .toLocaleString / .valueOf all exist. They dispatch on
(js-this) so Array.prototype.X.call-style calls work.
Unblocks String.prototype.* tests that set up '__instance = new Object(true)'
and then probe __instance.hasOwnProperty.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Adds __callable__ to the Object global dict: zero args returns {}, one-arg
returns the arg (which mirrors spec ToObject for non-null/undefined). This
unblocks many test262 tests that write 'new Object(true)' or 'Object(5)'
— they were failing with 'Not callable: {:entries ...}' because Object
was a plain dict with no call protocol.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Previously fn.length always returned 0 — so the 'length value' test262 tests
failed. Now js-fn-length inspects the lambda's parameter list (via
lambda-params primitive) and counts non-rest params. For functions/components
and callable dicts it still returns 0 (can't introspect arity in those cases).
6 new unit tests, 520/522 total.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Number dict was missing parseInt/parseFloat members and had MAX_VALUE=0
because SX parses 1e308 as 0 (exponent overflow). Now MAX_VALUE is computed
at load time by doubling until the next step would be Infinity
(js-max-value-approx returns 2^1023-ish, good enough as a finite sentinel).
POSITIVE_INFINITY / NEGATIVE_INFINITY / NaN now also use function-form values
(js-infinity-value, js-nan-value) so we don't depend on SX's inf/-inf/-nan
being roundtrippable as literals.
js-number-to-fixed now returns 'NaN' / 'Infinity' / '-Infinity' for
non-finite values. Also handles negative numbers correctly via |scaled|.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Many test262 tests write 'assert(condition, msg)' as a plain call, not
'assert.sameValue(...)'. The stub now sets assert.__callable__ to
__assert_call__ so the dispatch in js-call-plain finds a callable.
Also widens verifyNotEnumerable etc. to 5-arg signatures — some tests call
them with (o, name, value, writable, configurable).
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
js-get-prop on a function receiver only routed .prototype before; now also
handles .name (returns ''), .length (returns 0), and .call/.apply/.bind
as bound function references.
Previously Math.abs.length crashed with 'TypeError: length is not a function'.
Similarly for arr.sort.call which is a common test262 pattern.
Pass rate stable at 514/516.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Four coercion fixes that together unblock many test262 cases:
1. js-to-number(undefined) now returns NaN (was 0). Fixes Number(undefined),
isNaN(undefined), Math ops on undefined.
2. js-string-to-number returns NaN for non-numeric strings (via new
js-is-numeric-string?). Previously returned 0 for 'abc'.
3. parseInt('123abc', 10) → 123 (walks digits until first invalid char),
supports radix 2..36.
4. parseFloat('3.14xyz') → 3.14 (walks float prefix).
5. encodeURIComponent / decodeURIComponent / encodeURI / decodeURI —
new URI-helper implementations.
8 new unit tests, 514/516 total.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Array.from({length: 3, 0: 'a', 1: 'b', 2: 'c'}) used to return ['3','a','b','c']
because js-iterable-to-list walked dict keys in insertion order and included
the 'length' key as a value.
Now the dict branch checks for 'length' key first — if present, delegates to
js-arraylike-to-list which reads indices 0..length-1. Otherwise falls back
to value-order for plain objects.
Fixes Array.from, spread (...dict), and destructure from array-likes.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
The js-array-method / js-string-method dispatch tables had the new methods,
but the Array.prototype and String.prototype dicts that feed
Array.prototype.X.call(...) only had the original set. Now they include
all: Array.prototype.{at,unshift,splice,flatMap,findLast,findLastIndex,
reduceRight,toString,toLocaleString,keys,values,entries,copyWithin,
toReversed,toSorted,lastIndexOf}, and String.prototype.{at,codePointAt,
lastIndexOf,localeCompare,replaceAll,normalize,toLocale*Case}.
Also adds String.raw (trivial stub).
No unit test additions — these methods already tested via direct calls
on instances. 506/508 unchanged.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Previously NaN / Infinity were SX symbols that couldn't be (define)'d
because the SX tokenizer parses 'NaN' and 'Infinity' as numeric literals.
js-transpile-ident now rewrites NaN -> (js-nan-value), Infinity ->
(js-infinity-value), each a zero-arg function returning the appropriate
IEEE value ((/ 0.0 0.0) and (/ 1.0 0.0)).
Also fixes js-number-is-nan: in this SX, (= nan nan) returns true, so the
classic 'v !== v' trick doesn't work. Now checks (inspect v) against
'nan'/'-nan' strings.
Extends js-strict-eq: NaN === NaN returns false per ES spec.
8 new unit tests, 497/499 total.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
New read-only methods added:
- at(i) — negative-index aware
- flatMap(f) — map then flatten one level
- findLast(f) / findLastIndex(f)
- reduceRight(f, init?)
- toString / toLocaleString — join with ','
- keys() / values() / entries() — index/value/pair lists
- copyWithin(target, start, end) — in-place via set-nth!
- toReversed() / toSorted() — non-mutating variants
Mutating methods (unshift, splice) are stubs that return correct lengths
but don't mutate — we don't have a pop-first!/clear! primitive to rebuild
the list in place. Tracked as a runtime limitation.
10 new unit tests, 479/481 total. Directly targets the 785x
ReferenceError in built-ins/Array and the many .toString() crashes.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Runtime gains hs-get-selection: prefers window.__test_selection stash,
falls back to real getSelection().toString(). Compiler rewrites
`(ref "selection")` to `(hs-get-selection)`. Generator detects the
createRange + setStart/setEnd + addRange block and emits a single
host-set! on __test_selection with the text slice; sidesteps the need
for a fully propagating DOM range/text-node mock.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
All five subsystems now have design docs pending review on per-subsystem
worktree branches. Correcting E36: upstream uses `socket NAME URL ... end`
with implicit `.rpc` Proxy, not `with proxy { send, receive }`.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
Two generator changes: (a) `parse_run_locals` for Pattern 2
(`var R = await run(...)`) now recognises `result: <literal>` in the
opts dict and binds it to `it` so `run("its foo", {result: {foo: "foo"}})`
produces `(eval-hs-locals "its foo" (list (list (quote it) {:foo "foo"})))`.
Also adds the same extraction to Pattern 1 (`expect(run(...)).toBe(...)`).
(b) `_hs-wrap-body` emitted by the generator no longer shadows `it` to
nil — it only binds `event` — so eval-hs-locals's outer `it` binding is
visible inside the wrapped body. `eval-hs` still binds `it` nil at its
own `fn` wrapper so nothing regresses.
Suite hs-upstream-expressions/possessiveExpression: 22/23 → 23/23.
Smoke 0-195: 162/195 unchanged.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
`hs-on` now wraps each event handler in a `guard` that catches thrown
exceptions and re-dispatches them as an `exception` DOM event on the
same target with `{error: e}` as detail. The `on exception(error)`
handler, registered the same way, receives the event and destructures
`error` from the detail. Wrapping skips `exception`/`error` event
handlers to avoid infinite loops — those bubble out as before.
Suite hs-upstream-throw: 5/7 → 7/7. Smoke 0-195: 162/195 unchanged.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
