makepad

History

Admin b19e80d987 script-compute: prog, pulse, spring_step and remap are the shared stdlib's, and a kernel eases by name -- one definition for documents, shaders and kernels Documents' helpers are compiled into the kernels they feed, so a document calling a VM-only helper (Motion's prog/pulse/spring_step, the native ease(@name, u)) could not share it with a kernel; the P(DOOM) plates carried their own copies for that reason. - std/shared.splash (documents, shaders, kernels): prog(t, a, b) (0 at a, 1 at b, held outside; b below a runs from 1 down to 0, a = b steps), remap(x, a, b, c, d), pulse(t, t0, half_life), spring_step(t, freq, damping). The kernel prelude's remap and std.anim's pulse (an exp form of the same curve) are deleted; anim.pulse_sum uses the shared one. - The kernel parser reads `@name` and lowers ease(@ease_x, u) to std.ease's x(u) (@linear: clamp; @ease_in/@ease_out/@ease_in_out: quad), Motion's formulas; an ease(…) without an @name is an ordinary call (a kernel's own `ease`). Checked: cargo test --release -p makepad-script-compute --features vm (all, the AI-style corpus with its own ease functions included); every P(DOOM) plate rendered through the commercial change on top. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>		2026-10-02 11:56:55 +02:00
..
anim.splash	script-compute: prog, pulse, spring_step and remap are the shared stdlib's, and a kernel eases by name -- one definition for documents, shaders and kernels	2026-10-02 11:56:55 +02:00
beat.splash	script (compute): Splash modules and the kernel stdlib, plus host components -- a kernel can import modules. A module is Splash text of top-level fns and consts (module.rs). The host resolves each import to its text and passes (path, source) pairs to kernel::compile_with_modules; `use std.curve.` brings names in unqualified, `use std.field as f` and `use lib("id", "rev") as x` give a name, and a qualified call to a std module (`curve.sample(..)`) needs no `use`. A module's items are renamed by its alias and its own references follow, with locals shadowing them. Modules may import modules, and cycles and missing modules are errors at the `use`. A kernel's own names shadow imported ones, and two globs bringing one name are an error. Errors inside a module are reported at the kernel's call, like the prelude's; syntax errors name the module, line and column. There is no privileged tier: a library or AI-written module compiles to exactly the AIR of the same stdlib function (tested). Library items a kernel does not reach are pruned before lowering, so an unused import costs nothing (this now also drops unreached prelude tables). The parser gains `use` items, `const`, `"strings"` (only for lib()), `m.f(..)` qualified calls and `x: f64` annotations. The stdlib (std/.splash): std.shared is SX1's shared stdlib (knob, rot2, luma, palette, hsv2rgb, sd_*, bayer4, eases; exported as module::SHARED_STD for the shader compiler, in scope by default); std.curve (arc-length sampling over a cumulative table, point_at, spline_at, bezier2, arc, offset2); std.field (marching squares: cell_case, segments, segment, with segment tangent and midpoint for labels; grad); std.poly (area, winding, contains, perimeter, centroid); std.ease (Motion's ease formulas in f64 rounded once, bit-exact for the polynomial, circ, back and bounce curves; spring); std.anim (tween, keys, stepped, spring_to, pulse, pulse_sum, follow, accelerate); std.cam (project, to_screen, unproject, sphere/box visibility); std.beat (beat_at, time_of_beat, next_downbeat, word_progress, word_at, hit, env); std.search (bounded binary search). Host components (host.rs) are a registry of the few heavy Rust functions a kernel may call: typed scalar parameters and results, buffer slices (buffer, word offset, word length) with a maximum length and write permission, a worst-case cost (Program::cost charges it per call), a host-memory touch count and a determinism tier (portable kernels call only tier X). A call is the new AIR statement CallHost: the function is a compile-time registry index, and ir::validate checks the index, arity, types, results defined once, and that each slice names a bound buffer with the right permission; audio programs never call out. At run time slices are clamped to their buffers and maxima and seen as HostSlices (word access through atomics, no Rust references over kernel memory); a panic or error zeroes the results and sets ctx K_HOST_ERR (RunStats::host_error), never unwinding into generated code. The scalar backend calls one fixed trampoline around which it saves and restores the caller-saved registers; NEON declines host calls, and a written slice keeps the kernel on one thread. The registry is append-only and host-extensible (host::register at start-up: text.outline registers from the text crate). One built-in proves it: poly.triangulate (ear clipping of a simple polygon of up to 256 points, tier X). The ctx gains K_HOST_ERR at word 22 (K_PARAMS moves to 23). audio_aot/src/fuse.rs gets a two-line hunk for the new Item::Use (audio shaders still accept and ignore `use`). Checked: cargo test --release -p makepad-script-compute -p makepad-script-audio-aot (audio 21 with the 36 golden hashes unchanged). New: modules 6 (a library module and a kernel's own fn compile to the stdlib's exact AIR; resolution, shadowing, glob conflicts, nesting, cycles, error spans; unused imports cost nothing; marching squares bit-equal to a Rust reference at three levels; curves, polygons, Motion's eases bit-exact, keyframes, pulses, beats, camera; the shared stdlib in kernels). host 6 (native == interpreter with values live across calls; a panicking function sets the error word with zeroed results; hostile offsets and lengths clamped at buffer ends and the maximum; contract errors; triangulating a concave and a convex polygon covers their areas exactly; validator rejections). Existing suites green: neon 4, portable 4, sched 5, sched_alloc 1, soundness 14, kernels 3, admission 5, compiler_fuzz 2.	2026-09-30 11:18:33 +02:00
cam.splash	script (compute): Splash modules and the kernel stdlib, plus host components -- a kernel can import modules. A module is Splash text of top-level fns and consts (module.rs). The host resolves each import to its text and passes (path, source) pairs to kernel::compile_with_modules; `use std.curve.` brings names in unqualified, `use std.field as f` and `use lib("id", "rev") as x` give a name, and a qualified call to a std module (`curve.sample(..)`) needs no `use`. A module's items are renamed by its alias and its own references follow, with locals shadowing them. Modules may import modules, and cycles and missing modules are errors at the `use`. A kernel's own names shadow imported ones, and two globs bringing one name are an error. Errors inside a module are reported at the kernel's call, like the prelude's; syntax errors name the module, line and column. There is no privileged tier: a library or AI-written module compiles to exactly the AIR of the same stdlib function (tested). Library items a kernel does not reach are pruned before lowering, so an unused import costs nothing (this now also drops unreached prelude tables). The parser gains `use` items, `const`, `"strings"` (only for lib()), `m.f(..)` qualified calls and `x: f64` annotations. The stdlib (std/.splash): std.shared is SX1's shared stdlib (knob, rot2, luma, palette, hsv2rgb, sd_*, bayer4, eases; exported as module::SHARED_STD for the shader compiler, in scope by default); std.curve (arc-length sampling over a cumulative table, point_at, spline_at, bezier2, arc, offset2); std.field (marching squares: cell_case, segments, segment, with segment tangent and midpoint for labels; grad); std.poly (area, winding, contains, perimeter, centroid); std.ease (Motion's ease formulas in f64 rounded once, bit-exact for the polynomial, circ, back and bounce curves; spring); std.anim (tween, keys, stepped, spring_to, pulse, pulse_sum, follow, accelerate); std.cam (project, to_screen, unproject, sphere/box visibility); std.beat (beat_at, time_of_beat, next_downbeat, word_progress, word_at, hit, env); std.search (bounded binary search). Host components (host.rs) are a registry of the few heavy Rust functions a kernel may call: typed scalar parameters and results, buffer slices (buffer, word offset, word length) with a maximum length and write permission, a worst-case cost (Program::cost charges it per call), a host-memory touch count and a determinism tier (portable kernels call only tier X). A call is the new AIR statement CallHost: the function is a compile-time registry index, and ir::validate checks the index, arity, types, results defined once, and that each slice names a bound buffer with the right permission; audio programs never call out. At run time slices are clamped to their buffers and maxima and seen as HostSlices (word access through atomics, no Rust references over kernel memory); a panic or error zeroes the results and sets ctx K_HOST_ERR (RunStats::host_error), never unwinding into generated code. The scalar backend calls one fixed trampoline around which it saves and restores the caller-saved registers; NEON declines host calls, and a written slice keeps the kernel on one thread. The registry is append-only and host-extensible (host::register at start-up: text.outline registers from the text crate). One built-in proves it: poly.triangulate (ear clipping of a simple polygon of up to 256 points, tier X). The ctx gains K_HOST_ERR at word 22 (K_PARAMS moves to 23). audio_aot/src/fuse.rs gets a two-line hunk for the new Item::Use (audio shaders still accept and ignore `use`). Checked: cargo test --release -p makepad-script-compute -p makepad-script-audio-aot (audio 21 with the 36 golden hashes unchanged). New: modules 6 (a library module and a kernel's own fn compile to the stdlib's exact AIR; resolution, shadowing, glob conflicts, nesting, cycles, error spans; unused imports cost nothing; marching squares bit-equal to a Rust reference at three levels; curves, polygons, Motion's eases bit-exact, keyframes, pulses, beats, camera; the shared stdlib in kernels). host 6 (native == interpreter with values live across calls; a panicking function sets the error word with zeroed results; hostile offsets and lengths clamped at buffer ends and the maximum; contract errors; triangulating a concave and a convex polygon covers their areas exactly; validator rejections). Existing suites green: neon 4, portable 4, sched 5, sched_alloc 1, soundness 14, kernels 3, admission 5, compiler_fuzz 2.	2026-09-30 11:18:33 +02:00
curve.splash	script (compute): Splash modules and the kernel stdlib, plus host components -- a kernel can import modules. A module is Splash text of top-level fns and consts (module.rs). The host resolves each import to its text and passes (path, source) pairs to kernel::compile_with_modules; `use std.curve.` brings names in unqualified, `use std.field as f` and `use lib("id", "rev") as x` give a name, and a qualified call to a std module (`curve.sample(..)`) needs no `use`. A module's items are renamed by its alias and its own references follow, with locals shadowing them. Modules may import modules, and cycles and missing modules are errors at the `use`. A kernel's own names shadow imported ones, and two globs bringing one name are an error. Errors inside a module are reported at the kernel's call, like the prelude's; syntax errors name the module, line and column. There is no privileged tier: a library or AI-written module compiles to exactly the AIR of the same stdlib function (tested). Library items a kernel does not reach are pruned before lowering, so an unused import costs nothing (this now also drops unreached prelude tables). The parser gains `use` items, `const`, `"strings"` (only for lib()), `m.f(..)` qualified calls and `x: f64` annotations. The stdlib (std/.splash): std.shared is SX1's shared stdlib (knob, rot2, luma, palette, hsv2rgb, sd_*, bayer4, eases; exported as module::SHARED_STD for the shader compiler, in scope by default); std.curve (arc-length sampling over a cumulative table, point_at, spline_at, bezier2, arc, offset2); std.field (marching squares: cell_case, segments, segment, with segment tangent and midpoint for labels; grad); std.poly (area, winding, contains, perimeter, centroid); std.ease (Motion's ease formulas in f64 rounded once, bit-exact for the polynomial, circ, back and bounce curves; spring); std.anim (tween, keys, stepped, spring_to, pulse, pulse_sum, follow, accelerate); std.cam (project, to_screen, unproject, sphere/box visibility); std.beat (beat_at, time_of_beat, next_downbeat, word_progress, word_at, hit, env); std.search (bounded binary search). Host components (host.rs) are a registry of the few heavy Rust functions a kernel may call: typed scalar parameters and results, buffer slices (buffer, word offset, word length) with a maximum length and write permission, a worst-case cost (Program::cost charges it per call), a host-memory touch count and a determinism tier (portable kernels call only tier X). A call is the new AIR statement CallHost: the function is a compile-time registry index, and ir::validate checks the index, arity, types, results defined once, and that each slice names a bound buffer with the right permission; audio programs never call out. At run time slices are clamped to their buffers and maxima and seen as HostSlices (word access through atomics, no Rust references over kernel memory); a panic or error zeroes the results and sets ctx K_HOST_ERR (RunStats::host_error), never unwinding into generated code. The scalar backend calls one fixed trampoline around which it saves and restores the caller-saved registers; NEON declines host calls, and a written slice keeps the kernel on one thread. The registry is append-only and host-extensible (host::register at start-up: text.outline registers from the text crate). One built-in proves it: poly.triangulate (ear clipping of a simple polygon of up to 256 points, tier X). The ctx gains K_HOST_ERR at word 22 (K_PARAMS moves to 23). audio_aot/src/fuse.rs gets a two-line hunk for the new Item::Use (audio shaders still accept and ignore `use`). Checked: cargo test --release -p makepad-script-compute -p makepad-script-audio-aot (audio 21 with the 36 golden hashes unchanged). New: modules 6 (a library module and a kernel's own fn compile to the stdlib's exact AIR; resolution, shadowing, glob conflicts, nesting, cycles, error spans; unused imports cost nothing; marching squares bit-equal to a Rust reference at three levels; curves, polygons, Motion's eases bit-exact, keyframes, pulses, beats, camera; the shared stdlib in kernels). host 6 (native == interpreter with values live across calls; a panicking function sets the error word with zeroed results; hostile offsets and lengths clamped at buffer ends and the maximum; contract errors; triangulating a concave and a convex polygon covers their areas exactly; validator rejections). Existing suites green: neon 4, portable 4, sched 5, sched_alloc 1, soundness 14, kernels 3, admission 5, compiler_fuzz 2.	2026-09-30 11:18:33 +02:00
ease.splash	tween, script-compute: one easing family -- ease(@name, u) in the shared stdlib reads Motion's ease table, expo is the classic curve, the stdlib's own ease_* functions are gone	2026-10-02 11:12:19 +02:00
field.splash	script (compute): Splash modules and the kernel stdlib, plus host components -- a kernel can import modules. A module is Splash text of top-level fns and consts (module.rs). The host resolves each import to its text and passes (path, source) pairs to kernel::compile_with_modules; `use std.curve.` brings names in unqualified, `use std.field as f` and `use lib("id", "rev") as x` give a name, and a qualified call to a std module (`curve.sample(..)`) needs no `use`. A module's items are renamed by its alias and its own references follow, with locals shadowing them. Modules may import modules, and cycles and missing modules are errors at the `use`. A kernel's own names shadow imported ones, and two globs bringing one name are an error. Errors inside a module are reported at the kernel's call, like the prelude's; syntax errors name the module, line and column. There is no privileged tier: a library or AI-written module compiles to exactly the AIR of the same stdlib function (tested). Library items a kernel does not reach are pruned before lowering, so an unused import costs nothing (this now also drops unreached prelude tables). The parser gains `use` items, `const`, `"strings"` (only for lib()), `m.f(..)` qualified calls and `x: f64` annotations. The stdlib (std/.splash): std.shared is SX1's shared stdlib (knob, rot2, luma, palette, hsv2rgb, sd_*, bayer4, eases; exported as module::SHARED_STD for the shader compiler, in scope by default); std.curve (arc-length sampling over a cumulative table, point_at, spline_at, bezier2, arc, offset2); std.field (marching squares: cell_case, segments, segment, with segment tangent and midpoint for labels; grad); std.poly (area, winding, contains, perimeter, centroid); std.ease (Motion's ease formulas in f64 rounded once, bit-exact for the polynomial, circ, back and bounce curves; spring); std.anim (tween, keys, stepped, spring_to, pulse, pulse_sum, follow, accelerate); std.cam (project, to_screen, unproject, sphere/box visibility); std.beat (beat_at, time_of_beat, next_downbeat, word_progress, word_at, hit, env); std.search (bounded binary search). Host components (host.rs) are a registry of the few heavy Rust functions a kernel may call: typed scalar parameters and results, buffer slices (buffer, word offset, word length) with a maximum length and write permission, a worst-case cost (Program::cost charges it per call), a host-memory touch count and a determinism tier (portable kernels call only tier X). A call is the new AIR statement CallHost: the function is a compile-time registry index, and ir::validate checks the index, arity, types, results defined once, and that each slice names a bound buffer with the right permission; audio programs never call out. At run time slices are clamped to their buffers and maxima and seen as HostSlices (word access through atomics, no Rust references over kernel memory); a panic or error zeroes the results and sets ctx K_HOST_ERR (RunStats::host_error), never unwinding into generated code. The scalar backend calls one fixed trampoline around which it saves and restores the caller-saved registers; NEON declines host calls, and a written slice keeps the kernel on one thread. The registry is append-only and host-extensible (host::register at start-up: text.outline registers from the text crate). One built-in proves it: poly.triangulate (ear clipping of a simple polygon of up to 256 points, tier X). The ctx gains K_HOST_ERR at word 22 (K_PARAMS moves to 23). audio_aot/src/fuse.rs gets a two-line hunk for the new Item::Use (audio shaders still accept and ignore `use`). Checked: cargo test --release -p makepad-script-compute -p makepad-script-audio-aot (audio 21 with the 36 golden hashes unchanged). New: modules 6 (a library module and a kernel's own fn compile to the stdlib's exact AIR; resolution, shadowing, glob conflicts, nesting, cycles, error spans; unused imports cost nothing; marching squares bit-equal to a Rust reference at three levels; curves, polygons, Motion's eases bit-exact, keyframes, pulses, beats, camera; the shared stdlib in kernels). host 6 (native == interpreter with values live across calls; a panicking function sets the error word with zeroed results; hostile offsets and lengths clamped at buffer ends and the maximum; contract errors; triangulating a concave and a convex polygon covers their areas exactly; validator rejections). Existing suites green: neon 4, portable 4, sched 5, sched_alloc 1, soundness 14, kernels 3, admission 5, compiler_fuzz 2.	2026-09-30 11:18:33 +02:00
poly.splash	script (compute): Splash modules and the kernel stdlib, plus host components -- a kernel can import modules. A module is Splash text of top-level fns and consts (module.rs). The host resolves each import to its text and passes (path, source) pairs to kernel::compile_with_modules; `use std.curve.` brings names in unqualified, `use std.field as f` and `use lib("id", "rev") as x` give a name, and a qualified call to a std module (`curve.sample(..)`) needs no `use`. A module's items are renamed by its alias and its own references follow, with locals shadowing them. Modules may import modules, and cycles and missing modules are errors at the `use`. A kernel's own names shadow imported ones, and two globs bringing one name are an error. Errors inside a module are reported at the kernel's call, like the prelude's; syntax errors name the module, line and column. There is no privileged tier: a library or AI-written module compiles to exactly the AIR of the same stdlib function (tested). Library items a kernel does not reach are pruned before lowering, so an unused import costs nothing (this now also drops unreached prelude tables). The parser gains `use` items, `const`, `"strings"` (only for lib()), `m.f(..)` qualified calls and `x: f64` annotations. The stdlib (std/.splash): std.shared is SX1's shared stdlib (knob, rot2, luma, palette, hsv2rgb, sd_*, bayer4, eases; exported as module::SHARED_STD for the shader compiler, in scope by default); std.curve (arc-length sampling over a cumulative table, point_at, spline_at, bezier2, arc, offset2); std.field (marching squares: cell_case, segments, segment, with segment tangent and midpoint for labels; grad); std.poly (area, winding, contains, perimeter, centroid); std.ease (Motion's ease formulas in f64 rounded once, bit-exact for the polynomial, circ, back and bounce curves; spring); std.anim (tween, keys, stepped, spring_to, pulse, pulse_sum, follow, accelerate); std.cam (project, to_screen, unproject, sphere/box visibility); std.beat (beat_at, time_of_beat, next_downbeat, word_progress, word_at, hit, env); std.search (bounded binary search). Host components (host.rs) are a registry of the few heavy Rust functions a kernel may call: typed scalar parameters and results, buffer slices (buffer, word offset, word length) with a maximum length and write permission, a worst-case cost (Program::cost charges it per call), a host-memory touch count and a determinism tier (portable kernels call only tier X). A call is the new AIR statement CallHost: the function is a compile-time registry index, and ir::validate checks the index, arity, types, results defined once, and that each slice names a bound buffer with the right permission; audio programs never call out. At run time slices are clamped to their buffers and maxima and seen as HostSlices (word access through atomics, no Rust references over kernel memory); a panic or error zeroes the results and sets ctx K_HOST_ERR (RunStats::host_error), never unwinding into generated code. The scalar backend calls one fixed trampoline around which it saves and restores the caller-saved registers; NEON declines host calls, and a written slice keeps the kernel on one thread. The registry is append-only and host-extensible (host::register at start-up: text.outline registers from the text crate). One built-in proves it: poly.triangulate (ear clipping of a simple polygon of up to 256 points, tier X). The ctx gains K_HOST_ERR at word 22 (K_PARAMS moves to 23). audio_aot/src/fuse.rs gets a two-line hunk for the new Item::Use (audio shaders still accept and ignore `use`). Checked: cargo test --release -p makepad-script-compute -p makepad-script-audio-aot (audio 21 with the 36 golden hashes unchanged). New: modules 6 (a library module and a kernel's own fn compile to the stdlib's exact AIR; resolution, shadowing, glob conflicts, nesting, cycles, error spans; unused imports cost nothing; marching squares bit-equal to a Rust reference at three levels; curves, polygons, Motion's eases bit-exact, keyframes, pulses, beats, camera; the shared stdlib in kernels). host 6 (native == interpreter with values live across calls; a panicking function sets the error word with zeroed results; hostile offsets and lengths clamped at buffer ends and the maximum; contract errors; triangulating a concave and a convex polygon covers their areas exactly; validator rejections). Existing suites green: neon 4, portable 4, sched 5, sched_alloc 1, soundness 14, kernels 3, admission 5, compiler_fuzz 2.	2026-09-30 11:18:33 +02:00
search.splash	script (compute): Splash modules and the kernel stdlib, plus host components -- a kernel can import modules. A module is Splash text of top-level fns and consts (module.rs). The host resolves each import to its text and passes (path, source) pairs to kernel::compile_with_modules; `use std.curve.` brings names in unqualified, `use std.field as f` and `use lib("id", "rev") as x` give a name, and a qualified call to a std module (`curve.sample(..)`) needs no `use`. A module's items are renamed by its alias and its own references follow, with locals shadowing them. Modules may import modules, and cycles and missing modules are errors at the `use`. A kernel's own names shadow imported ones, and two globs bringing one name are an error. Errors inside a module are reported at the kernel's call, like the prelude's; syntax errors name the module, line and column. There is no privileged tier: a library or AI-written module compiles to exactly the AIR of the same stdlib function (tested). Library items a kernel does not reach are pruned before lowering, so an unused import costs nothing (this now also drops unreached prelude tables). The parser gains `use` items, `const`, `"strings"` (only for lib()), `m.f(..)` qualified calls and `x: f64` annotations. The stdlib (std/.splash): std.shared is SX1's shared stdlib (knob, rot2, luma, palette, hsv2rgb, sd_*, bayer4, eases; exported as module::SHARED_STD for the shader compiler, in scope by default); std.curve (arc-length sampling over a cumulative table, point_at, spline_at, bezier2, arc, offset2); std.field (marching squares: cell_case, segments, segment, with segment tangent and midpoint for labels; grad); std.poly (area, winding, contains, perimeter, centroid); std.ease (Motion's ease formulas in f64 rounded once, bit-exact for the polynomial, circ, back and bounce curves; spring); std.anim (tween, keys, stepped, spring_to, pulse, pulse_sum, follow, accelerate); std.cam (project, to_screen, unproject, sphere/box visibility); std.beat (beat_at, time_of_beat, next_downbeat, word_progress, word_at, hit, env); std.search (bounded binary search). Host components (host.rs) are a registry of the few heavy Rust functions a kernel may call: typed scalar parameters and results, buffer slices (buffer, word offset, word length) with a maximum length and write permission, a worst-case cost (Program::cost charges it per call), a host-memory touch count and a determinism tier (portable kernels call only tier X). A call is the new AIR statement CallHost: the function is a compile-time registry index, and ir::validate checks the index, arity, types, results defined once, and that each slice names a bound buffer with the right permission; audio programs never call out. At run time slices are clamped to their buffers and maxima and seen as HostSlices (word access through atomics, no Rust references over kernel memory); a panic or error zeroes the results and sets ctx K_HOST_ERR (RunStats::host_error), never unwinding into generated code. The scalar backend calls one fixed trampoline around which it saves and restores the caller-saved registers; NEON declines host calls, and a written slice keeps the kernel on one thread. The registry is append-only and host-extensible (host::register at start-up: text.outline registers from the text crate). One built-in proves it: poly.triangulate (ear clipping of a simple polygon of up to 256 points, tier X). The ctx gains K_HOST_ERR at word 22 (K_PARAMS moves to 23). audio_aot/src/fuse.rs gets a two-line hunk for the new Item::Use (audio shaders still accept and ignore `use`). Checked: cargo test --release -p makepad-script-compute -p makepad-script-audio-aot (audio 21 with the 36 golden hashes unchanged). New: modules 6 (a library module and a kernel's own fn compile to the stdlib's exact AIR; resolution, shadowing, glob conflicts, nesting, cycles, error spans; unused imports cost nothing; marching squares bit-equal to a Rust reference at three levels; curves, polygons, Motion's eases bit-exact, keyframes, pulses, beats, camera; the shared stdlib in kernels). host 6 (native == interpreter with values live across calls; a panicking function sets the error word with zeroed results; hostile offsets and lengths clamped at buffer ends and the maximum; contract errors; triangulating a concave and a convex polygon covers their areas exactly; validator rejections). Existing suites green: neon 4, portable 4, sched 5, sched_alloc 1, soundness 14, kernels 3, admission 5, compiler_fuzz 2.	2026-09-30 11:18:33 +02:00
shared.splash	script-compute: prog, pulse, spring_step and remap are the shared stdlib's, and a kernel eases by name -- one definition for documents, shaders and kernels	2026-10-02 11:56:55 +02:00