basedpl 0.1.45__tar.gz → 0.1.48__tar.gz

{basedpl-0.1.45 → basedpl-0.1.48}/.cargo/config.toml

@@ -3,6 +3,10 @@
 [build]
 rustflags = ["-C", "passes=slp-vectorizer"]
 
+# rustymath uses Accelerate's per-thread BLAS controls on macOS.
+[env]
+MACOSX_DEPLOYMENT_TARGET = "15.0"
+
 # x86-64 builds need a CPU with AVX2 (x86-64-v3). The kernels rely on its rounding and wider vector instructions.
 [target.'cfg(target_arch = "x86_64")']
 rustflags = ["-C", "target-cpu=x86-64-v3", "-C", "passes=slp-vectorizer"]

{basedpl-0.1.45 → basedpl-0.1.48}/.github/workflows/ci.yml

@@ -27,13 +27,13 @@ jobs:
         with:
           python-version: '3.12'
       - if: runner.os != 'Linux'
-        run: pip install 'fastws-cli>=0.0.22' && ${{ env.STAGE_BPL }}
+        run: pip install 'fastws-cli>=0.0.25' && ${{ env.STAGE_BPL }}
       - uses: PyO3/maturin-action@v1
         with:
-          args: --profile dist --out dist -i python3.10 -i python3.11 -i python3.12 -i python3.13
+          args: --profile dist --no-default-features --out dist -i python3.10 -i python3.11 -i python3.12 -i python3.13
           manylinux: auto
           # This runs inside the manylinux container, whose old glibc lets the binary run on older Linux distributions.
-          before-script-linux: export PATH="/opt/python/cp310-cp310/bin:$PATH" && python3.10 -m pip install 'fastws-cli>=0.0.22' && ${{ env.STAGE_BPL }}
+          before-script-linux: export PATH="/opt/python/cp310-cp310/bin:$PATH" && python3.10 -m pip install 'fastws-cli>=0.0.25' && ${{ env.STAGE_BPL }}
       - uses: actions/upload-artifact@v7
         with:
           name: wheels-${{ matrix.os }}

{basedpl-0.1.45 → basedpl-0.1.48}/.gitignore

@@ -14,6 +14,7 @@ dist/
 build/
 .venv/
 venv/
+node_modules/
 .env
 .DS_Store
 .ipynb_checkpoints/

{basedpl-0.1.45 → basedpl-0.1.48}/Cargo.lock

@@ -93,7 +93,7 @@ checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
 
 [[package]]
 name = "basedpl"
-version = "0.1.45"
+version = "0.1.48"
 dependencies = [
  "base64 0.23.1",
  "bytemuck",
@@ -129,6 +129,7 @@ dependencies = [
  "stacker",
  "strength_reduce",
  "tempfile",
+ "unicode-script",
  "unicode-width",
  "uuid",
  "walkdir",
@@ -139,7 +140,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-cli"
-version = "0.1.45"
+version = "0.1.48"
 dependencies = [
  "async-trait",
  "basedpl",
@@ -153,7 +154,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-py"
-version = "0.1.45"
+version = "0.1.48"
 dependencies = [
  "basedpl",
  "bytemuck",
@@ -168,7 +169,7 @@ dependencies = [
 
 [[package]]
 name = "basedpl-wasm"
-version = "0.1.45"
+version = "0.1.48"
 dependencies = [
  "basedpl",
  "js-sys",
@@ -493,9 +494,9 @@ checksum = "869b0adbda23651a9c5c0c3d270aac9fcb52e8622a8f2b17e57802d7791962f2"
 
 [[package]]
 name = "equivalent"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+checksum = "00d174d5400e5e8fd687ad1049e2f578285fa914201b1af7e8b112a4546bd826"
 
 [[package]]
 name = "errno"
@@ -547,6 +548,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e634e2e0ebac1ee034020da1ca582e17ffe4e0f5e985823721e168928136dcb"
 dependencies = [
  "crc32fast",
+ "libz-sys",
  "miniz_oxide 0.9.1",
  "zlib-rs",
 ]
@@ -859,9 +861,9 @@ dependencies = [
 
 [[package]]
 name = "json5"
-version = "1.3.1"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "733a844dbd6fef128e98cb4487b887cb55454d92cd9994b1bafe004fabbe670c"
+checksum = "c77a3f1d413a994290ebe4f96047763a84d04a1f31492c51328402986d7fe5fa"
 dependencies = [
  "serde",
  "ucd-trie",
@@ -910,6 +912,17 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
+[[package]]
+name = "libz-sys"
+version = "1.1.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f710a23e6dbf193214fd46ca56a9d6864e550abe86202184532ae7275e46de19"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.12.1"
@@ -1110,6 +1123,12 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
 
+[[package]]
+name = "pkg-config"
+version = "0.3.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548"
+
 [[package]]
 name = "plotters"
 version = "0.3.7"
@@ -1398,9 +1417,9 @@ dependencies = [
 
 [[package]]
 name = "rustymath"
-version = "0.1.14"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c4b9032437f945f3db8fa14a4382bec40d21cb4edf1adb8711af6c43b1bb4c5"
+checksum = "a56363f0b8b7fe94b0035c30839b56349b48c8d1576b0265072ff96914c6241b"
 dependencies = [
  "half",
  "hashbrown 0.17.1",
@@ -1672,9 +1691,9 @@ dependencies = [
 
 [[package]]
 name = "tokio"
-version = "1.53.2"
+version = "1.53.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e95f91fcc7a621e8b030f6aa23c71fe9838ae2fb4d8118b75602a328f5144044"
+checksum = "ce3335fa71841cda333a58d7615b03901380ecf09d59b3296d21f8bbac0dde4e"
 dependencies = [
  "bytes",
  "libc",
@@ -1754,6 +1773,12 @@ version = "1.0.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
 
+[[package]]
+name = "unicode-script"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "383ad40bb927465ec0ce7720e033cb4ca06912855fc35db31b5755d0de75b1ee"
+
 [[package]]
 name = "unicode-segmentation"
 version = "1.13.3"
@@ -1798,6 +1823,12 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -2052,7 +2083,7 @@ checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
 [[package]]
 name = "xtask"
-version = "0.1.45"
+version = "0.1.48"
 dependencies = [
  "anyhow",
  "serde_json",
@@ -2085,18 +2116,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.62"
+version = "0.8.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86502bf56ac7c77571a32e2647bb2a15894565e981fb2a48d7bde2d91c965a9d"
+checksum = "e5fe1f8f1b06191a00962174c61aa5005e0bb391a6d80d07e24d115c01a92ed8"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.62"
+version = "0.8.63"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5457206954b06561e2608c7e19cf58b1926586d999c246eebe4502f7e2039d1a"
+checksum = "863ad3ac83293fb4d740aedbfdc9240dd8d1a50c1099acd76ce80ce7c7230c7f"
 dependencies = [
  "proc-macro2",
  "quote",

{basedpl-0.1.45 → basedpl-0.1.48}/Cargo.toml

@@ -2,7 +2,7 @@
 members = ["py"]
 
 [workspace.package]
-version = "0.1.45"
+version = "0.1.48"
 edition = "2021"
 rust-version = "1.98"
 license = "Apache-2.0"
@@ -40,29 +40,32 @@ incremental = false
 lto = false
 strip = true
 
+[features]
+default = ["native"]
+# rustymath's own linear algebra, beside Accelerate on macOS, for `RUSTYMATH_NATIVE=1`. The Mac release builds turn it off.
+native = ["rustymath/native"]
+
 [dependencies]
 csv = "1"
 tempfile = "3"
 serde = ">=1.0.229, <2"
 serde_json = { version = "1", features = ["arbitrary_precision", "preserve_order"] }
 unicode-width = { version = ">=0.2.2, <1", default-features = false }
+unicode-script = "0.5"
 num-rational = ">=0.4.2, <1"
 num-complex = { version = ">=0.4.6, <1", features = ["bytemuck"] }
 num-bigint = ">=0.4.6, <0.5"
 num-traits = ">=0.2.19, <1"
 half = { version = ">=2.7.1, <3", features = ["num-traits", "bytemuck"] }
-rustymath = ">=0.1.14, <1"
+rustymath = { version = ">=0.1.18, <1", default-features = false }
 strength_reduce = ">=0.2.4, <1"
 rand = ">=0.10.2, <1"
 # AnswerDotAI's fork measures text with a canvas, which works in a Web Worker: plotters-rs/plotters#746.
 plotters = { git = "https://github.com/AnswerDotAI/plotters.git", branch = "master", default-features = false, features = ["svg_backend", "colormaps", "full_palette"] }
-image = { version = ">=0.25.6, <1", default-features = false, features = ["png", "jpeg"] }
-png = ">=0.18.1, <1"
 base64 = ">=0.22.1, <1"
 stacker = ">=0.1.25, <1"
 foldhash = ">=0.2.0, <1"
 bytemuck = { version = ">=1.25.2, <2", features = ["extern_crate_alloc"] }
-flate2 = ">=1.1.10, <2"
 json5 = ">=1.3.1, <2"
 roxmltree = { version = ">=0.21.1, <1", default-features = false, features = ["std"] }
 sha2 = ">=0.10.9, <1"
@@ -76,6 +79,14 @@ nix = { version = ">=0.31.3, <1", default-features = false, features = ["user"]
 [target.'cfg(target_vendor = "apple")'.dependencies]
 # The timing lock's QoS call, which keeps a timing on the performance cores.
 libc = ">=0.2.190, <1"
+# The Mac build links the zlib that macOS ships, in place of compiling `miniz_oxide`.
+flate2 = { version = ">=1.1.10, <2", default-features = false, features = ["zlib"] }
+
+[target.'cfg(not(target_vendor = "apple"))'.dependencies]
+flate2 = ">=1.1.10, <2"
+# Macs decode and encode images through ImageIO instead.
+image = { version = ">=0.25.6, <1", default-features = false, features = ["png", "jpeg"] }
+png = ">=0.18.1, <1"
 
 [target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dependencies]
 chrono = { version = ">=0.4.45, <0.5", features = ["unstable-locales"] }

{basedpl-0.1.45 → basedpl-0.1.48}/DEV.md

@@ -2,7 +2,7 @@
 
 Keep the language concise to write, simple to read and consistent to understand. A design rule is a plan on trial. Discuss it when applying it makes a useful expression harder to read, removes something expressible or requires another special case. APL familiarity and compatibility are not costs in that decision. Change callers with an API change instead of adding compatibility layers.
 
-Speed and simplicity come before edge cases no real user meets. Follow IEEE, Rust and CPU behaviour where it gives a reasonable result. Don't add precision, sign normalization or defensive passes without an agreed need.
+Speed and simplicity come before edge cases no real user meets. Follow IEEE, Rust and CPU behaviour where it gives a reasonable result. The last bits of a result can differ between thread counts, platforms, builds and runs. Never spend speed, memory or code to make them agree. Don't add precision, sign normalization or defensive passes without an agreed need.
 
 ## You MUST read this ENTIRE section in FULL first
 
@@ -20,23 +20,27 @@ Build nothing else without discussion: no scratch crates, alternate target direc
 
 An already-running Python process retains its loaded extension. In a kernel, use `from basedpl.worker import fresh; fresh(code)` to check the installed `bpl` in a fresh worker instead of restarting the kernel. A BPL error raises `BplError`. Check one expression and read its result before building on it. `basedpl.bpltests.check_file` and `check_page` check reference files and documentation through the worker without building Rust.
 
-Measure with `BASEDPL_COSTS=1 cargo test --test speed -- --nocapture` or `basedpl.bpltests.time_cases(cases)`. Both use copies of the same data as the unit. Budgets are single-thread measurements. Use `time_cases(..., threads=...)` separately for scaling. `speed_costs()` reads the cases in `tests/speed.txt`; `cases=` selects expressions and `wasm=DIR` selects a browser build. `logged_costs(log)` reads CI output, and `cargo_costs(path)` runs either project's speed test. `set_budgets(native, wasm, run)` applies the rule in the budget file; `path=` selects rustymath's `tests/speed.txt`. The manual `Speed` workflow measures the native and wasm builds on CI.
+Measure with `BASEDPL_COSTS=1 cargo test --test speed -- --nocapture` or `basedpl.bpltests.time_cases(cases)`. Both count costs in copies. A copy is the time to write as many floats as the data has items, each negated, into a second buffer. Budgets are single-thread measurements. Use `time_cases(..., threads=...)` separately for scaling. `speed_costs()` reads the cases in `tests/speed.txt`. `cases=` selects expressions, `wasm=DIR` selects a browser build, `bpl=PATH` selects another native `bpl`, and `native=True` times rustymath's own linear algebra, which dev builds compile in. `logged_costs(log)` reads CI output, and `cargo_costs(path)` runs either project's speed test.
 
-Cooperating tools share `/tmp/aai-ws-timing.lock`. Timings take it exclusively. `cargo develop`, `cargo wasm`, the reference test and pytest take it shared. Other Rust tests and bare Cargo commands do not all take it. After five minutes a timing fails; a build/test proceeds without the lock. Never hold it in the shared kernel process or coordinate timings manually. A timing launched there would block behind the hold and stall other agents' kernel calls. Native timings set rustymath's current-thread count to one and request user-interactive macOS QoS to favour performance cores. QoS is not CPU affinity.
+The manual `Speed` workflow measures the native and wasm builds on CI. When you review a run, look mainly for costs that changed by more than 20%, especially where several similar operations changed by similar amounts. Never raise budgets mechanically from a run's costs, because mechanical rises can lock in poor performance. Study each slowdown until you know its cause. Raise a budget only for a slowdown you've judged reasonable, never for a minor variation. `set_budgets(native, wasm, cases=cases)` applies the rule in the budget file to the cases that `cases` names. Name only the cases whose budgets should change. Without `cases`, it changes every case with a cost. Pass `run=` only when the run sets every budget. It replaces the header line that names the run all the CI figures come from. `path=` selects rustymath's `tests/speed.txt`.
+
+To compare a change with the build before it, copy the installed `bpl` before the change, then time both copies in turn with `speed_costs(bpl=path)` or `time_cases(..., bpl=path)`. Don't restore old code in the shared tree to get a baseline. On macOS, native timings of matrix products and decompositions mostly measure Accelerate. Rustymath's DEV.md says how to time rustymath's own kernels.
+
+Cooperating tools share `/tmp/aai-ws-timing.lock`. Timings take it exclusively. `cargo develop`, `cargo wasm`, the reference test and pytest take it shared. Other Rust tests and bare Cargo commands do not all take it. After five minutes a timing fails; a build/test proceeds without the lock. After 30 seconds, an exclusive wait prints the processes with the lock file open. The list can include processes that are only waiting for the lock. Never hold it in the shared kernel process or coordinate timings manually. A timing launched there would block behind the hold and stall other agents' kernel calls. Native timings set rustymath's current-thread count to one and request user-interactive macOS QoS to favour performance cores. QoS is not CPU affinity.
 
 Run `cargo wasm` during development only for browser work. Agents use `cargo wasm --out DIR` and set `BASEDPL_WASM=DIR` when running `node --test tests/wasm.mjs` and `node --no-liftoff --test tests/wasm-speed.mjs`. This avoids replacing a module another agent is using. For other edits under `cfg(web)` or `host_web.rs`, check compilation with `cargo check -p basedpl --target wasm32-unknown-unknown`.
 
 ### X86-64 machine code
 
-To inspect x86 code on this Mac, run this in basedpl or rustymath:
+To inspect the x86-64 code that CI and Linux run, build the library for Linux x86-64. In basedpl:
 
 ```bash
-cargo build --lib --release --target x86_64-apple-darwin --target-dir /tmp/aai-ws-x86
+CC_x86_64_unknown_linux_gnu=clang cargo build --lib --release --target x86_64-unknown-linux-gnu --target-dir /tmp/aai-ws-x86 -p basedpl
 ```
 
-That target is installed here. Its x86-64 config flags match those used for CI's hot loops; the `test` profile inherits release's optimization settings. Run it only to answer an x86-code question. It does not take the timing lock and can disturb timings running alongside it.
+In rustymath, use `-p rustymath`. The target is Linux because macOS builds leave out rustymath's native linear algebra kernels. That target is installed here. `-p` builds only the library, because the Python extension crates can't be built for Linux on this Mac. `CC_x86_64_unknown_linux_gnu=clang` lets Apple's `clang` assemble the x86-64 source in basedpl's `psm` dependency, because this Mac has no `x86_64-linux-gnu-gcc`. Don't move that setting into `.cargo/config.toml`. CI's Linux release builds also read that file, and their manylinux container has no `clang`. The build matches CI's `test` profile in its x86-64 flags and optimization settings. Run it only to answer an x86-code question. It doesn't take the timing lock and can disturb timings running alongside it.
 
-Read the newest `lib<crate>-<hash>.rlib` under `/tmp/aai-ws-x86/x86_64-apple-darwin/release/deps` with `objdump -d -r --no-show-raw-insn --disassemble-symbols=NAME`. `-r` identifies called functions. `objdump` warns for each archive object without that symbol. `-C` matches demangled names but splits them at commas; for a generic name containing a comma, get its mangled name from `nm` and omit `-C`. Generic code belongs to the crate that instantiates it. Don't use `--emit asm`: the resulting codegen-unit arrangement can inline differently from the build being inspected.
+Read the newest `lib<crate>-<hash>.rlib` under `/tmp/aai-ws-x86/x86_64-unknown-linux-gnu/release/deps` with `objdump -d -r --no-show-raw-insn --disassemble-symbols=NAME`. `-r` identifies called functions. `objdump` warns for each archive object without that symbol. `-C` matches demangled names but splits them at commas; for a generic name containing a comma, get its mangled name from `nm` and omit `-C`. Generic code belongs to the crate that instantiates it. Don't use `--emit asm`: the resulting codegen-unit arrangement can inline differently from the build being inspected.
 
 ## Workspace, builds and CI
 
@@ -54,6 +58,8 @@ Rust 1.98 or later supplies algebraic float operations. `test` inherits `release
 
 `fastws`'s `cargo develop` builds profile `test`, installs the extension and stages `bpl` into the venv. `py/` enables PyO3's `extension-module` and supplies its link arguments without libpython. Editable installs use `fastws.build_backend`; they install metadata and a path to `python/` without compiling Rust. After a standalone `uv sync` or editable pip install, run `cargo develop`. `ws-sync` performs that rebuild after syncing. Wheels use maturin for the extension and `cargo stage` for the Python-free CLI. Linux staging runs inside the manylinux container.
 
+Basedpl's crates pass on rustymath's default `native` feature, which rustymath's DEV.md describes. Each depends on the crate below it with `default-features = false` and makes `native` its own default. The release job builds wheels with `--no-default-features`. `cargo stage` always builds without default features. The released Mac builds therefore leave out rustymath's own linear algebra. On Apple targets, `flate2` uses the system zlib. Other targets keep its Rust backend, `miniz_oxide`.
+
 Use published dependency ranges with the lower bounds required by the APIs in use. `Cargo.toml` names a published rustymath range; the `~/aai-ws` Cargo patch selects the sibling checkout locally. CI resolves published crates. Release rustymath changes before relying on them in basedpl CI. Don't edit fastws-generated Cargo patches, `.git/fastws-cargo-key` or workspace configuration, and don't commit the workspace-generated `Cargo.lock`. `meta/` is ignored planning material, not contributor documentation. `[tool.uv] cache-keys` tracks packaging manifests, not Rust sources.
 
 `Test` runs native and wasm jobs on pushes to main and pull requests. Native CI runs `cargo test`, editable installation, `cargo develop`, pytest, `bpl-nb` and `nbdev-test`. Python tests use the same test-profile build. The wasm job builds with `cargo wasm --strip` and runs both Node suites. Both jobs use `ubicloud-standard-4`; speed budgets are set for that runner. They generate a lockfile before restoring `Swatinem/rust-cache`, making dependency changes part of the cache key. `Speed` is manually triggered and restores those caches.
@@ -66,7 +72,7 @@ LTO-off incremental builds keep an edit from recompiling every caller that inlin
 
 Generic loop instances can concentrate in the defining module's codegen unit. Mark loop helpers `#[inline]` when their instances need to compile with the caller's kernel table, including nested helpers. Kernel tables have separate modules: `booleans`, `wholes`, `float_arithmetic`, `float_kernels` and `complex_kernels`. `at_widths!` gives the concrete widths their own modules. Keep new tables separate and add kernel specializations only for measured gains.
 
-Use `cargo build --lib --bins --profile test --timings` to inspect the normal build. Its report under `target/cargo-timings/` separates frontend and codegen time. `BASEDPL_UNITS=1 cargo test --test units -- --nocapture` lists large units and their functions. `BASEDPL_SIZES=pattern cargo test --test units -- --nocapture` measures machine code matching a demangled-name regex. These commands diagnose the current compilation arrangement; don't create scratch builds to approximate it.
+Use `cargo build --lib --bins --profile test --timings` to inspect the normal build. Its report under `target/cargo-timings/` separates frontend and codegen time. `BASEDPL_UNITS=1 cargo test --test units -- --nocapture` lists large units and their functions. `BASEDPL_SIZES=pattern cargo test --test units -- --nocapture` measures machine code matching a demangled-name regex. `BASEDPL_SIZES` sees only basedpl's own codegen units. `BASEDPL_SIZES_DIFF=old:new cargo test --test units machine_code_growth -- --nocapture` compares two binaries, such as copies of `bpl` from before and after a change, by generic function across every crate. These commands diagnose the current compilation arrangement; don't create scratch builds to approximate it.
 
 ## Code map
 
@@ -93,6 +99,8 @@ User-facing language rules belong in `nbs/syntax.qmd`, `evaluation.qmd`, `number
 
 The lexer/parser records byte spans and structural syntax without evaluating expressions. `parse_at` distinguishes complete input, incomplete input and errors at a given float width. Public `parse` uses f64; `Session::parse` uses the session width. `syntax_tree` supplies source tools with structural nodes and recovers invalid chunks as `Error` nodes. `highlight` shares the lexer.
 
+`symbols.rs` owns APL, simplified and traditional Hanzi spellings. Its rows also hold each glyph's names: a glyph name for the character, which is also its page's file name in `nbs/glyphs/`, and a name for each valence, or one name where both valences do the same thing. The glyph reference, named entry, help and Python's exported names all read them there. Parsing always accepts them together, canonicalizing token decisions while retaining original source and spans. Han characters are reserved outside strings and comments. The `notation` preference affects structured function/operator display, not stored source, serialization or structural APIs; help and editor metadata use the same spelling table.
+
 The binder resolves runtime categories right to left. It owns unfinished strands, trains and bound arguments; shared function nodes are immutable. Grammatical reduction produces application requests instead of calling functions. Primitive/operator rows own names, operand kinds, ranks, pervasion, axis behaviour and reduction identities. Change those rows instead of duplicating metadata in consumers. A non-extending primitive above its natural ranks runs through Rank; pervasive Each/Outer/Rank paths reuse whole-array kernels.
 
 Dot names rewrite to Pick, and dot brackets/subscripts to selection. Dot parentheses evaluate a namespace: `T.(expr)` and `T⍎text` use the keyed entries of `T` as locals, resolve other names in the caller and keep assignments local. They share the scoped execution route and lexical lifetime checks. Between functions, dot remains inner product.
@@ -107,7 +115,7 @@ Tail calls reuse frames while preserving lexical dependencies. Handlers disable
 
 ## Values, layouts and assignment
 
-`Value` holds a number, character, function, operator or shared array. Compact storage holds Booleans, narrow integers, width-specific floats/complex numbers or characters. Mixed storage holds `Value`s and memoizes its prototype and innermost lexical dependency. Other properties are computed when needed. A layout and its shared `Arc<Storage>` can be copied separately; changing axes need not copy items. `Buffer`, `Value::buffer` and `from_buffer` are the public width-preserving frontend boundary.
+`Value` holds a number, character, function, operator or shared array. Compact storage holds Booleans, narrow integers, width-specific floats/complex numbers or characters. Mixed storage holds `Value`s and memoizes its prototype and innermost lexical dependency. Other properties are computed when needed. An array holds its layout and its storage in one allocation. Its `Shape` holds ranks 0 to 2 inline, so a small array allocates no shape. Constructors take `impl Into<Shape>`: pass a slice, or an array such as `[n]`, rather than building a `Vec`. A shape, key or name change on a shared array makes a view of the base array's storage and copies no items. `Buffer`, `Value::buffer` and `from_buffer` are the public width-preserving frontend boundary.
 
 Atoms, rank-0 arrays and singleton vectors are distinct. Function nodes retain handles, not lexical frames or Python objects. Functions match by their parts; dfns and generators match by identity. Operators can be values and can cross the native Python boundary. Values and function nodes are `Send + Sync`.
 
@@ -115,7 +123,7 @@ Numeric storage fills with zero and characters with blank. Mixed nonempty arrays
 
 `Layout` owns dimensions, position keys, axis names and optional renderer metadata. Agreement unites keys and broadcasts through index maps. Missing positions read each source's prototype. Agreement pairs equal axis names first. It pairs remaining axes positionally unless both have different names. Result assembly drops colliding axis names; public name attachment rejects duplicates. Contracted axes require equal key sets and retain the first order. Nonempty key lists with no named positions become unkeyed; empty record keys survive.
 
-`Gather` owns copying and widening. `Steps` describes strides, ranges/fills, rotations and offset tables. Structural operations should use `remap`/gathering rather than reconstructing `Value`s per item. Equal-shape cells copy in blocks. `Items` reads counts, positions and axes from compact storage without boxing every item. Shape, tally, positions and predicates have dedicated integer/Boolean builders.
+`Gather` owns copying and widening. `Steps`, from rustymath's `gather`, describes strides, ranges/fills, rotations and offset tables. `Gather::walk` copies compact storage through `rustymath::gather::walk`. Structural operations should use `remap`/gathering rather than reconstructing `Value`s per item. Equal-shape cells copy in blocks. `Items` reads counts, positions and axes from compact storage without boxing every item. Shape, tally, positions and predicates have dedicated integer/Boolean builders.
 
 Selective assignment and structural Under share label-based target discovery. Function-Under applies its selector to both arguments independently before calling its operand; labels then identify writeback into the right argument. Positions-Under passes the left argument whole. Keep those contracts distinct. Keyed values align to selected keys, and nested paths retain empty-cell structure.
 
@@ -125,7 +133,7 @@ Rank/Each/Outer assemble cells through shared layout/prototype rules. A 0-cell p
 
 Axis nodes select/move axes and reuse Rank when the function has no direct axis meaning. Vector-axis reduction uses the general composed-ravel rule, preserving axis order and the whole seed. Single-axis reductions retain direct kernels. Layout-only changes share storage. Structural results retain renderers where their rank permits; scans and in-place changes copy complete layouts. Match ignores renderers.
 
-Inverse nodes propagate fixed-argument sides through composition. Candidate-building primitive inverses validate by applying the primitive again. Inverse scans share forward scan's seed/axis validation. Agenda calls its selector once, then passes the original arguments to the selected branch. Computed operands for Rank, Axis, Stencil and Agenda use shared operand evaluation. Python constructs these nodes directly, not by generating source.
+Inverse nodes propagate fixed-argument sides through composition. `f⁻¹←g` and `f∂←g` replace the binding with a `Ruled` node, which holds the function with its hand-written inverse and derivative. Calling it calls the function. `⁻¹` and `∂` use the rules, and Under counts an attached inverse as keeping every item. Candidate-building primitive inverses validate by applying the primitive again. Inverse scans share forward scan's seed/axis validation. Agenda calls its selector once, then passes the original arguments to the selected branch. Computed operands for Rank, Axis, Stencil and Agenda use shared operand evaluation. Python constructs these nodes directly, not by generating source.
 
 ## Numbers and backend ownership
 
@@ -141,11 +149,11 @@ Floats use IEEE NaN, infinity and signed zero. Comparison treats NaN as unequal;
 
 Only f64 comparisons use the session tolerance, from 0 to `1E-14`. f32/f16 compare exactly except fixed-point convergence, which uses four ulps; f64 convergence uses `1E-14` independently of the preference. Index/count/Boolean/character-offset conversion uses `near_integer` with the fixed default tolerance, not the comparison preference. The tolerant types and objects come from rustymath. Keep independent inside/outside-tolerance tests with exact/mixed controls; don't use language comparison as its own oracle.
 
-`search.rs` selects compact exact or tolerant backends. Exact integer/Boolean/character storage uses keys; float searches use their width. Integer haystacks accept the whole-number shortcut only for exactly whole float needles. Tolerant indexing validates whole-key matches unless the haystack is exactly whole and falls back to buckets on mismatch. Classification intentionally chains tolerance through sorted runs, so it need not match every member to one representative. Other cells use exact hashes or first-number buckets with `Value::matches` confirmation, falling back to pairwise comparison where indexing is unsuitable. Grade is stable. Position buffers use u32 and become integer storage without another pass.
+`search.rs` selects compact exact or tolerant backends. Exact integer/Boolean/character storage uses keys; float searches use their width. Integer haystacks accept the whole-number shortcut only for exactly whole float needles. Tolerant indexing validates whole-key matches unless the haystack is exactly whole and falls back to buckets on mismatch. Classification intentionally chains tolerance through sorted runs, so it need not match every member to one representative. Other cells use exact hashes or first-number buckets with `Value::matches` confirmation, falling back to pairwise comparison where indexing is unsuitable. Grade is stable. Position buffers use u32 and become integer storage without another pass. `⍷` and monadic Key take each class's positions from `search::class_positions`, which keeps a class's own buffer for 32-bit positions and copies narrower ones once from the shared buffer. Dyadic Key selects rows through `Grouped::each` slices. Key with the operand `≢⊢`, which `≢∘⊢` also builds, counts its classes through `search::class_counts` and builds no positions.
 
 `Domain` and `with_field!` select working reals, Complex64 or BigRational for generic numeric algorithms. Compact storage selects the domain without scanning its items. `number::read` converts once; `Field::array` builds compact float/complex results without a `Number` per item. Each caller lists the domains it supports. Compact complex input does not take a real path merely because all imaginary parts are zero; results built through `Value::complex` can normalize to float storage.
 
-Rustymath owns the mathematical algorithms. Basedpl owns pervasion, storage, numeric promotion, axes and language policy. Approximate matrix solve/pseudoinverse and decomposition use native rustymath factorizations. Exact solve/pseudoinverse/determinant use rational field algorithms. Generic permanent and polynomial helpers also run at floating/complex field types. Singular/wide matrix division gives least-norm solutions. LU eligibility and SVD cutoffs are rustymath policy, not duplicated here.
+Rustymath owns the mathematical algorithms. Basedpl owns pervasion, storage, numeric promotion, axes and language policy. Approximate matrix solve/pseudoinverse and decomposition use rustymath factorizations. On macOS, rustymath sends much of this work to Accelerate, as its DEV.md describes. No platform-specific adapter belongs here. The Cargo configuration, for Cargo's own builds, and `pyproject.toml`, for the wheels, both set the macOS deployment minimum to 15. Exact solve/pseudoinverse/determinant use rational field algorithms. Generic permanent and polynomial helpers also run at floating/complex field types. Singular/wide matrix division gives least-norm solutions. LU eligibility and SVD cutoffs are rustymath policy, not duplicated here.
 
 `•decompose`/`•decompose⁻¹` share domain reading and `Factor` dispatch, with options for kind, vectors and complete QR. Polynomial adapters choose compact evaluation or generic field operations; gradients differentiate coefficients before evaluating. Number-theory adapters supply cancellation checks and assemble result cells. Distribution constructors expose native density/CDF/quantile/sample functions. Compact continuous calls use slice objects. Discrete samples and finite discrete quantiles are exact integers.
 
@@ -165,7 +173,7 @@ A failed compact kernel leaves placeholder results and triggers a wider/exact/co
 
 Folds by algebraic float operations can regroup. Contiguous subtraction/division folds use `Alternating`; quotients fall back to item-by-item folding if their products leave the normal range. Boolean scans compose truth-table maps; comparison scans compute both possible totals in bulk and use `reduce::chosen`. Seeds, axis lanes and scalar fallback preserve the language's accumulation direction. Generic reductions stay right-associated and preserve operand call order/effects. Monadic `f.g` is the exception: it memoizes each minor's expansion, and a cached minor does not repeat operand calls or their effects. Determinant/permanent fast paths use the appropriate rustymath backend.
 
-The automatic Rayon scheduler currently serves rustymath elementwise `many` and `pairs`, not general matrix products, factorizations or reduction loops. It adapts to call cost, uses `RAYON_NUM_THREADS` by default and accepts current-thread overrides through `parallel::set_threads` (0 default, 1 serial). Nested Rayon work does not split again; wasm is serial. Small converted chunks and fusion's serial outer traversal limit the work available to it. Don't infer multicore execution from a large array alone.
+The automatic Rayon scheduler serves rustymath elementwise `many` and `pairs`, folds through `reduce::along`, fused chains and matrix products. Scans don't split. Decompositions split in the products of their blocked updates, the passes of their Hermitian and bidiagonal reductions, and their divide-and-conquer merges. `rank` sends dyadic `+.×` and `⌹`, monadic `⌹` and `-.×`, and `•decompose` over the 2-cells of an unkeyed stack with compact storage to `primitive::stacked` and `stacked_decompositions`. They run each cell through the rustymath function it uses alone. Rustymath's `parallel::stack_with` splits whole cells across threads in rounds, with `check_now` between rounds. A caller whose checks run far apart, such as a round or a rustymath `_with` callback, calls `check_now`, because `Context::check` reads the clock only on every 64th call. The scheduler adapts to call cost, uses `RAYON_NUM_THREADS` by default and accepts current-thread overrides through `parallel::set_threads` (0 default, 1 serial). `Session::evaluation` applies a session's `•prefs ["threads":n]` to each of its evaluations, then restores the thread's own setting. A session that never sets it keeps the evaluating thread's setting, such as the timing harness's one thread. Nested Rayon work does not split again; wasm is serial. A fused chain splits in pieces of whole blocks: an elementwise chain through `parallel::extended`, and a folded one through `reduce::fold_pieces`. On one thread an elementwise chain appends straight to its result, because copying each block into a piece's slots cost up to 1.2 copies there. Small converted chunks limit the work available to the scheduler. Don't infer multicore execution from a large array alone.
 
 Packed numeric, Boolean and equality-count inner products use `rustymath::linalg`. Integer calls use `Inner::checked` before relying on an exact compact result. Structural gather/compress and interval index also reuse rustymath. Measure generic/backend changes in both projects; callers' codegen and layout determine costs that isolated kernels miss.
 
@@ -201,7 +209,7 @@ The Jupyter adapter in `cli/src/kernel.rs` uses kernmini and a `ThreadWorker`. I
 
 ### Browser
 
-`cargo wasm` builds an incremental release-profile npm package with wasm-bindgen glue, language/input assets, grammar and canvas support. `--out DIR` leaves the docs' local playground assets alone; `--strip` removes function-name metadata for distribution. Keep wasm-bindgen glue and crate versions aligned through the workspace lock. Avoid fat LTO here because rebuild cost and enlarged stack frames conflict with browser development and recursion limits.
+`cargo wasm` builds an incremental release-profile npm package with wasm-bindgen glue, language/input assets, grammar and canvas support. `--out DIR` leaves the docs' local playground assets alone; `--strip` removes function-name metadata for distribution. Keep wasm-bindgen glue and crate versions aligned through the workspace lock. Avoid fat LTO here because rebuild cost and enlarged stack frames conflict with browser development and recursion limits. `wasm-objdump -h DIR/basedpl_wasm_bg.wasm` lists the module's section sizes, including `name`. `twiggy diff` matches functions by full name, including crate hashes that change between builds. To compare two builds by function, compare their `twiggy top -n 1000000 -f json` listings with the hashes removed.
 
 Browser `Session.run` streams MIME events and returns a protocol error or null. `eval` transfers values through `js.rs` but discards output and cannot export BPL functions/operators; `bind` imports page values/functions. Typed arrays transfer without another page-worker copy. JavaScript functions live in a thread-local registry and core function nodes hold slots, preserving Send/Sync values. `host_web.rs` implements the browser's clock, synchronous I/O/fetch and RegExp behaviour. File/URL reads resolve against the configured base. Unsupported native filesystem/locale operations stay unavailable; browser `•nput` writes only stdout and `•js` is browser-only.
 
@@ -211,9 +219,11 @@ The playground and gallery load released assets from jsDelivr, or local `nbs/pla
 
 `system.rs` owns case-insensitive system names, valence, item mapping and result prototypes. Native records use ordinary function nodes and calls. Empty native item mapping returns its declared prototype without calling the function. `data::Options` is the shared keyed-option decoder; formats don't invent separate option parsers.
 
+`minimize.rs` implements `⇄` on `rustymath::optimize`. A vector operand holds the options before the function, and a left argument binds to the function through `↣`. `Goal` evaluates the function at points in the start's layout. Where `Function::differentiable` holds, `Goal` also calls `f∂` for the gradient. `∂` itself uses the same test.
+
 CSV columns, JSON arrays and Python lists share `data::imported`: a non-fill finite float or any nonfinite float triggers float promotion when every number converts losslessly. Finite fills alone do not trigger it. Otherwise items keep their kinds. JSON objects/dictionaries stay mixed. Binary data uses exact bytes. Writes validate before opening and create exclusively unless overwrite is explicit. CSV/JSON/XML exports use `•csv⁻¹`, `•json⁻¹` and `•xml⁻¹`.
 
-`regex.rs` shares host regex state between match/replace native functions; hosts retain their own regex syntax. `xml.rs` represents keyed element trees and distinguishes XML escaping/validation from HTML raw script/style and void-element rules. SVG uses its own renderer. `image.rs` owns pixels, PNG/JPEG and APNG animations. Native/browser renderers use the MIME/byte formats their frontends support. `plot.rs` stores specs and draws SVG on demand; the renderer owns defaults/validation. Rendering options belong in their user pages and implementation comments.
+`regex.rs` shares host regex state between match/replace native functions; hosts retain their own regex syntax. `xml.rs` represents keyed element trees and distinguishes XML escaping/validation from HTML raw script/style and void-element rules. SVG uses its own renderer. `image.rs` owns pictures, their options and animation timing, as plain pixel buffers. Its `codec` module decodes and encodes those buffers through ImageIO on Apple targets (`image/imageio.rs`) and through the `image` and `png` crates elsewhere (`image/codecs.rs`). Native/browser renderers use the MIME/byte formats their frontends support. `plot.rs` stores specs and draws SVG on demand; the renderer owns defaults/validation. Rendering options belong in their user pages and implementation comments.
 
 `display.rs` owns plain/boxed/function display, elision and MIME rendering. Display settings affect implicit presentation, not returned values or `⍕`; explicit output prints all items. `•mime` calls a renderer with echo disabled and cancellation active. Failed implicit rendering falls back to text; interrupts/timeouts propagate. `canvas.rs` serializes drawing data and typed bytes; `canvas.js` and `nbs/driver.js` own browser playback. Keep formatting, serialization and rich output as separate contracts.
 

{basedpl-0.1.45 → basedpl-0.1.48}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: basedpl
-Version: 0.1.45
+Version: 0.1.48
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Requires-Dist: fastcore
 Requires-Dist: fastship>=0.0.11 ; extra == 'dev'
-Requires-Dist: fastws-cli>=0.0.24 ; extra == 'dev'
+Requires-Dist: fastws-cli>=0.0.25 ; extra == 'dev'
 Requires-Dist: maturin>=1.9.4,<2.0 ; extra == 'dev'
 Requires-Dist: pytest ; extra == 'dev'
 Requires-Dist: numpy ; extra == 'dev'

{basedpl-0.1.45/python/basedpl → basedpl-0.1.48/editors/jetbrains/BPL.tmbundle/Syntaxes}/bpl.tmLanguage.json

@@ -6,7 +6,7 @@
   ],
   "patterns": [
     {
-      "begin": "⍝",
+      "begin": "[⍝注]",
       "beginCaptures": {
         "0": {
           "name": "comment.line.bpl"
@@ -48,15 +48,15 @@
       "name": "source.bpl"
     },
     {
-      "match": "•[A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*",
+      "match": "[•系][A-Za-z_∆⍙][A-Za-z0-9_∆⍙]*",
       "name": "support.function.system.bpl"
     },
     {
-      "match": "¯?∞|¯?(\\d+(\\.\\d+)?|\\.\\d+)([eEₑ]¯?\\d+)?([jJⱼ]¯?(\\d+(\\.\\d+)?|\\.\\d+)([eEₑ]¯?\\d+)?|ₓ|[rᵣ]¯?\\d+)?",
+      "match": "[¯负負]?[∞永]|[¯负負]?(\\d+([.内內]\\d+)?|[.内內]\\d+)([eEₑ][¯负負]?\\d+)?([jJⱼ][¯负負]?(\\d+([.内內]\\d+)?|[.内內]\\d+)([eEₑ][¯负負]?\\d+)?|ₓ|[rᵣ][¯负負]?\\d+)?",
       "name": "constant.numeric.bpl"
     },
     {
-      "match": "⍬ₓ?",
+      "match": "[⍬空]ₓ?",
       "name": "constant.numeric.bpl"
     },
     {
@@ -85,23 +85,23 @@
       }
     },
     {
-      "match": "[\\+\\-×÷⌈⌊\\|\\*⍟○π√!∧∨⊼⊽\\~=≠<≤>≥⍳↦:⍴≢≡,⍪⊂⊃⊆∊∪∩⍋⍒↑↓⌽⊖⍉⊤⊥⍎⍕⌷⌹\\#↕⍭⨸⌻⍸⍷⊢⊣¿]",
+      "match": "[\\+加\\-减減×乘号號÷除⌈上⌊下\\|绝余絕餘\\*幂冪⍟对對○圆圓π周√根!阶拣階揀∧极且極∨析或⊼方否⊽双莫雙\\~非无無=等≠别初別<小≤限退>大≥达进達進⍳位↦至:键卸鍵⍴形≢数异數異≡同深,连連⍪接矩⊂包⊃选合選⊆巢段∊属展屬∪并独併獨∩交重⍋升⍒降↑取↓去拆⌽转轉⊖纵縱⍉翻⊤编編⊥译譯⍎行⍕文⌷索⌹解逆\\#复複↕窗⍭素⨸因⌻零值⍸处间處間⍷寻群尋⊢右⊣左¿掷抽擲]",
       "name": "support.function.bpl"
     },
     {
-      "match": "[¨⍨⊗⌸∂/⌿\\\\⍀⁰¹²³⁴⁵⁶⁷⁸⁹⁻ᵀᵘ]",
+      "match": "[¨遍⍨己换換⊗表⌸组組⇄优優∂导梯導/总總⌿汇匯\\\\累⍀续續⁰¹²³⁴⁵⁶⁷⁸⁹⁻ᵀᵘ]",
       "name": "keyword.operator.monadic.bpl"
     },
     {
-      "match": "[↣⍤∘⍠⍥↢\\.⍣⇄⊘@⍚⌺]",
+      "match": "[↣先⍤秩∘承⍠轴軸⍥经經↢后後\\.内內⍣次止⊘兼@于於⍚择擇⌺邻鄰]",
       "name": "keyword.operator.dyadic.bpl"
     },
     {
-      "match": "[⍺⍵⍶⍹∇⍢]",
+      "match": "[⍺甲⍵乙⍶丙⍹丁∇递遞⍢循]",
       "name": "variable.parameter.bpl"
     },
     {
-      "match": "[←⎕⋄\\?₀₁₂₃₄₅₆₇₈₉₋]",
+      "match": "[←是⎕出入⋄句\\?若₀₁₂₃₄₅₆₇₈₉₋]",
       "name": "keyword.control.bpl"
     }
   ]

{basedpl-0.1.45 → basedpl-0.1.48}/editors/jetbrains/BPL.xml

@@ -459,11 +459,6 @@
       <option name="OTHER" value="true" />
     </context>
   </template>
-  <template name="inverse-pair" value="⇄" description="⇄" shortcut="TAB">
-    <context>
-      <option name="OTHER" value="true" />
-    </context>
-  </template>
   <template name="inverted-question" value="¿" description="¿" shortcut="TAB">
     <context>
       <option name="OTHER" value="true" />
@@ -569,6 +564,11 @@
       <option name="OTHER" value="true" />
     </context>
   </template>
+  <template name="minimize" value="⇄" description="⇄" shortcut="TAB">
+    <context>
+      <option name="OTHER" value="true" />
+    </context>
+  </template>
   <template name="mix" value="⊃" description="⊃" shortcut="TAB">
     <context>
       <option name="OTHER" value="true" />

{basedpl-0.1.45 → basedpl-0.1.48}/editors/macos/BasedPL-de.bundle/Contents/Resources/BasedPL-de.keylayout

@@ -560,7 +560,7 @@
    <key code="16" output="⊂"/>
    <key code="17" output="∘"/>
    <key code="18" action="k18-m4"/>
-   <key code="19" output="“"/>
+   <key code="19" output="⌽"/>
    <key code="20" output="√"/>
    <key code="21" output="⇄"/>
    <key code="22" output="]"/>
@@ -1347,7 +1347,7 @@
    <key code="23" output="&#x001B;"/>
    <key code="24" output="'"/>
    <key code="25" output="}"/>
-   <key code="26" output="⌽"/>
+   <key code="26" output="|"/>
    <key code="27" output="¿"/>
    <key code="28" output="{"/>
    <key code="29" output="≠"/>

{basedpl-0.1.45 → basedpl-0.1.48}/editors/macos/BasedPL-de.txt

@@ -24,6 +24,7 @@ Option-z	⊂
 Option-t	∘
 Option-1	diaeresis prefix
 Option-Shift-1	¹
+Option-2	⌽
 Option-Shift-2	²
 Option-3	√
 Option-4	⇄
@@ -32,7 +33,6 @@ Control-Option-6	superscript prefix
 Option-Shift-5	subscript prefix
 Option-Shift-´	⋄
 Option-Shift-9	∨
-Control-Option-7	⌽
 Control-Option-Shift-7	¿
 Option-Shift-8	∞
 Option-0	∧

{basedpl-0.1.45 → basedpl-0.1.48}/editors/macos/BasedPL-es.bundle/Contents/Resources/BasedPL-es.keylayout

@@ -690,7 +690,7 @@
    <key code="16" action="k16-m5"/>
    <key code="17" output="‡"/>
    <key code="18" action="k18-m5"/>
-   <key code="19" output="²"/>
+   <key code="19" output="⌽"/>
    <key code="20" output="√"/>
    <key code="21" output="⁴"/>
    <key code="22" output="⁶"/>
@@ -1339,7 +1339,7 @@
    <key code="15" output="&#x0012;"/>
    <key code="16" output="&#x0019;"/>
    <key code="17" output="&#x0014;"/>
-   <key code="18" output="⌽"/>
+   <key code="18" output="1"/>
    <key code="19" output="2"/>
    <key code="20" output="3"/>
    <key code="21" output="4"/>

{basedpl-0.1.45 → basedpl-0.1.48}/editors/macos/BasedPL-es.txt

@@ -23,8 +23,7 @@ Option-r	⍴
 Option-y	•
 Option-t	∘
 Option-Shift-1	diaeresis prefix
-Control-Option-1	⌽
-Option-Shift-2	²
+Option-Shift-2	⌽
 Option-Shift-3	√
 Option-4	⇄
 Option-Shift-4	⁴