feat(ts): model typed allocation as a fresh JS array

quest/m3/ts-unsafe.md

@@ -33,10 +33,12 @@ none of its own `unsafe`.
   with a span; a pointer from elsewhere, such as a field, fails there loudly at run time.
   A pointer to an element JS keeps as an object, such as a tuple or the crate's struct, is
   that object, which knows no array it is in, so arithmetic on one stays refused:
-  hashbrown's buckets and kio's `log.rs` reach it. smallvec's pointer arithmetic
-  translates, but it spills to memory from `alloc::alloc`, which this Plan refuses, so it
-  translates whole only once the maintainer decides how a typed allocation
-  (`Layout::array::<T>`, then a cast to `*mut T`) is modeled or that smallvec is mapped.
+  hashbrown's buckets and kio's `log.rs` reach it.
+- Decided with the maintainer on 2026-11-01, typed allocation: memory from `alloc` for a
+  `Layout::array::<T>(n)`, or an equal layout of `T`'s size and alignment, cast to `*mut T`
+  is a fresh JS array of `T`s, which `realloc` copies and `dealloc` frees. Untyped and
+  byte allocation stay refused. smallvec spills to it, and `Vec::from_raw_parts` of it is
+  left.
 - Decided with the maintainer on 2026-11-02: a raw slice pointer is `rt.RawSlice`, its
   first element's pointer and its length, read through only where Rust reads, and an empty
   slice from a pointer into no array keeps that pointer through every part of it.
@@ -51,6 +53,10 @@ none of its own `unsafe`.
   `set_len` is refused, and a write past the length fails loudly at run time, since the
   JS array would grow by it. The spare slots need to live outside the array's length
   until `set_len` takes them.
+- `offset_from` between byte pointers into two views of one buffer, such as a slice's
+  `as_mut_ptr` and its `iter_mut`'s first element: each is an `rt.AtIndex` into its own
+  `Uint8Array`, so it fails loudly at run time where Rust measures the distance. Comparing
+  by buffer and byte offset closes it.
 - `UnsafeCell::raw_get`, `from_mut`, and `replace`, refused with their span: none is in
   moq's census at the pin.
 - A slice's pointer cast to an array's of its length, `*(s as *const [u8] as *const

ts/README.md

@@ -79,7 +79,7 @@ and each type a module of its own beside it, holding the type and its functions
 from. `rt.ts` beside them is the
 runtime: what std does that JS does not, with iterators in `rt/iter.ts`, `str`'s searches
 in `rt/str.ts`, the ASCII methods of `u8`, `char`, `[u8]`, and `str` in `rt/ascii.ts`, collections in `rt/collections.ts`, hashing in `rt/hash.ts`, ownership, atomics, and async in
-`rt/task.ts`, `f64`'s and `f32`'s methods in `rt/float.ts`, and `Duration` in `rt/time.ts`. What translates from std's own MIR,
+`rt/task.ts`, `f64`'s and `f32`'s methods in `rt/float.ts`, `Duration` in `rt/time.ts`, and `Layout` and memory from `alloc` in `rt/alloc.ts`. What translates from std's own MIR,
 `Option`'s, `Result`'s, and `Poll`'s methods, `==` of std's errors, `==` and ordering of a `Result` and a `Poll`, `cmp::max` and `min`, and the `str::parse` and
 `from_str_radix` of an integer or a `NonZero` and `bool`'s `str::parse`, goes in a module under its crate's name, as
 `core/option.ts` holds `map$1cf8u0y`. A dependency's modules go
@@ -118,6 +118,7 @@ crate translation reaches is refused, and so are two versions of one crate it re
 | `PeekMut<T>` | `rt.PeekMut<T>`, the `rt.Place` of a heap's greatest element, which sifts it down as it drops once `DerefMut` lent it |
 | `Ordering`, `DefaultHasher`, `RandomState` | `rt.Ordering`, which is `-1`, `0`, or `1`; `rt.Hasher`; `rt.RandomState`, the keys of the `DefaultHasher` it builds, never changed once made |
 | `Duration` | `rt.Duration`: `{ secs, nanos }`, std's whole seconds as an `rt.u64` and the nanoseconds past them, never changed once made |
+| `Layout`, `alloc::alloc` | `rt.Layout`: `{ size, align }`, never changed once made, checked as std's constructors check it; `alloc` gives an `rt.Block` of its bytes, which a cast of its pointer to `*mut T` the body shows came from `alloc` or `realloc` makes a JS array of `T`s, values JS copies, as an `rt.AtIndex` of its first; a cast back to `*mut u8` only as what `dealloc` or `realloc` takes, which free the array or copy it into a new one; its bytes, read, written, or cast to any other type, are refused, and fail at run time through a pointer from elsewhere |
 | closure | an arrow function, with `[Symbol.dispose]` if it owns a value that drops, and what makes its clone if a clone can't be itself |
 | `fn` pointer, function item as a value | the function, as a closure is typed: a `()` result is `undefined`, where a declared function returns `void` |
 | `&dyn Trait`, `&mut dyn Trait`, `Box<dyn Trait>`, `Arc<dyn Trait>` | an object with the trait's methods, its supertraits' included: `shape.area$Shape()`; behind an `Arc`, an `rt.ArcDyn` sharing the count of the `Arc` it was made from |
@@ -852,7 +853,7 @@ they need.
 
 ## Not yet
 
-Byte reinterpretation, pointer addresses, pointer arithmetic on a value JS keeps as an object (other than wrapping arithmetic on a null or dangling pointer), raw allocation, and unions whose
+Byte reinterpretation, pointer addresses, pointer arithmetic on a value JS keeps as an object (other than wrapping arithmetic on a null or dangling pointer), memory from `alloc` other than an array of values JS copies, and unions whose
 fields overlap in different types ([unsafe](/quest/m3/ts-unsafe.md)), and trait objects other than
 `&dyn Debug`, `&dyn Display`, `dyn Future`, `dyn Any`, `dyn Fn*`, `dyn Buf`, and the translated crates' traits'
 behind `&`, `&mut`, `Box`, or `Arc` ([trait objects](/quest/m3/ts-dyn.md)), fail translation. Until they translate, an item that needs one, such as a `dyn Error`, binds to

ts/fixtures/lang/expected/core/any.Any.ts

@@ -3,7 +3,7 @@
 import * as rt from "../rt.ts";
 import type * as Square from "../dyns.Square.ts";
 import type * as Tri from "../dyns.Tri.ts";
-import type * as Fault from "../fmt.Fault.ts";
+import type * as fmt_Fault from "../fmt.Fault.ts";
 
 export type Any = object;
 
@@ -32,9 +32,9 @@ export class of$dyns_Tri {
 }
 
 export class of$fmt_Fault {
-	v: Fault.Fault;
+	v: fmt_Fault.Fault;
 
-	constructor(v: Fault.Fault) {
+	constructor(v: fmt_Fault.Fault) {
 		this.v = v;
 	}
 }
@@ -96,9 +96,9 @@ export class ofPlace$dyns_Tri {
 }
 
 export class ofPlace$fmt_Fault {
-	v: rt.Place<Fault.Fault>;
+	v: rt.Place<fmt_Fault.Fault>;
 
-	constructor(v: rt.Place<Fault.Fault>) {
+	constructor(v: rt.Place<fmt_Fault.Fault>) {
 		this.v = v;
 	}
 }

ts/fixtures/lang/expected/core/bool.ts

@@ -98,6 +98,13 @@ export function thenSome$1jqdi5p(self: boolean, t: rt.Duration): rt.Duration | u
 	return t;
 }
 
+export function thenSome$0j2n934(self: boolean, t: [rt.u8, rt.u16]): [rt.u8, rt.u16] | undefined {
+	if (!self) {
+		return undefined;
+	}
+	return t;
+}
+
 export function thenSome$03chm1q(self: boolean, t: [rt.u8, rt.u8]): [rt.u8, rt.u8] | undefined {
 	if (!self) {
 		return undefined;

ts/fixtures/lang/expected/core/option.ts

@@ -26,6 +26,7 @@ import * as defaults_Made from "../defaults.Made.ts";
 import type * as dyns_Shape from "../dyns.Shape.ts";
 import * as edits_Named from "../edits.Named.ts";
 import type * as Ticked from "../generics.Ticked.ts";
+import type * as heap_Fault from "../heap.Fault.ts";
 import type * as hints_Unit from "../hints.Unit.ts";
 import type * as Badge from "../iters.Badge.ts";
 import type * as Quarter from "../iters.Quarter.ts";
@@ -1470,6 +1471,13 @@ export function mapOr$0f73bb7(self: [rt.u8, [rt.usize, rt.ByteSlice]] | undefine
 	return f(self);
 }
 
+export function mapOr$0hi5qhf(self: [rt.u8, rt.u16] | undefined, default_: rt.u8, f: (a0: [rt.u8, rt.u16]) => rt.u8): rt.u8 {
+	if (self === undefined) {
+		return default_;
+	}
+	return f(self);
+}
+
 export function mapOr$16umieg(self: [rt.usize, string] | undefined, default_: rt.usize, f: (a0: [rt.usize, string]) => rt.usize): rt.usize {
 	if (self === undefined) {
 		return default_;
@@ -1519,6 +1527,13 @@ export function mapOr$1m2xzon(self: rt.u8 | undefined, default_: boolean, f: (a0
 	return f(self);
 }
 
+export function mapOr$1qo6t0j(self: rt.u8 | undefined, default_: rt.u32, _: (a0: rt.u8) => rt.u32): rt.u32 {
+	if (self === undefined) {
+		return default_;
+	}
+	return self as rt.u32;
+}
+
 export function mapOr$18ph0j9(self: undefined | rt.None, default_: rt.u8, f: (a0: undefined) => rt.u8): rt.u8 {
 	if (self === rt.None) {
 		return default_;
@@ -1561,6 +1576,13 @@ export function okOr$1b6nkwr(self: rt.char | undefined, err: rt.u8): rt.Result<r
 	return rt.Ok(self);
 }
 
+export function okOr$1rxv64q(self: rt.Place<rt.u8> | undefined, err: heap_Fault.Fault): rt.Result<rt.Place<rt.u8>, heap_Fault.Fault> {
+	if (self === undefined) {
+		return rt.Err(err);
+	}
+	return rt.Ok(self);
+}
+
 export function okOr$0gtm15y(self: rt.ByteSlice | undefined, err: rt.u8 | undefined): rt.Result<rt.ByteSlice, rt.u8 | undefined> {
 	if (self === undefined) {
 		return rt.Err(err);
@@ -1624,6 +1646,13 @@ export function okOr$0g9lvh7(self: rt.u8 | undefined, _: undefined): rt.Result<r
 	return rt.Ok(self);
 }
 
+export function okOr$169x1m6(self: rt.usize | undefined, err: heap_Fault.Fault): rt.Result<rt.usize, heap_Fault.Fault> {
+	if (self === undefined) {
+		return rt.Err(err);
+	}
+	return rt.Ok(self);
+}
+
 export function okOrElse$0awp3vn(self: rt.ByteVec | undefined, err: () => string): rt.Result<rt.ByteVec, string> {
 	if (self === undefined) {
 		return rt.Err(err());

ts/fixtures/lang/expected/core/result.ts

@@ -13,6 +13,7 @@ import { eq$1horntk as float_parse_eq$1horntk } from "../core/num/float_parse.ts
 import { eq$1v93ipo as str_error_eq$1v93ipo, eq$1f3e51k as str_error_eq$1f3e51k } from "../core/str/error.ts";
 import { cmp$175ka5q as poll_cmp$175ka5q } from "../core/task/poll.ts";
 import { eq$0dhyfbb as time_eq$0dhyfbb } from "../core/time.ts";
+import type * as heap_Fault from "../heap.Fault.ts";
 import type * as locks_Tally from "../locks.Tally.ts";
 import * as Part from "../orders.Part.ts";
 import type * as returns_Error from "../returns.Error.ts";
@@ -746,6 +747,13 @@ export function mapOrElse$0jxx67n(self: rt.Result<rt.u8, rt.u16>, default_: (a0:
 	return default_(self.error);
 }
 
+export function mapErr$0fesv1f(self: rt.Result<rt.Layout, rt.LayoutError>, op: (a0: rt.LayoutError) => heap_Fault.Fault): rt.Result<rt.Layout, heap_Fault.Fault> {
+	if (self.ok) {
+		return self as rt.Result<rt.Layout, heap_Fault.Fault>;
+	}
+	return rt.Err(op(self.error));
+}
+
 export function mapErr$12w1s5x(self: rt.Result<rt.u32[], rt.u8>, _: (a0: rt.u8) => rt.u16): rt.Result<rt.u32[], rt.u16> {
 	if (self.ok) {
 		return self as rt.Result<rt.u32[], rt.u16>;

ts/fixtures/lang/expected/harness.ts

@@ -32,6 +32,7 @@ import { ints, strings, derived, written as fmt_written, counts as fmt_counts, r
 import { folds } from "./folds.ts";
 import { methods, runs } from "./generics.ts";
 import { values as hashes_values, random, bytes as hashes_bytes, own as hashes_own } from "./hashes.ts";
+import { spills, remnants, layouts } from "./heap.ts";
 import { hints, reserves } from "./hints.ts";
 import { holds } from "./holds.ts";
 import { u8Op, u16Op, u32Op, u64Op, u128Op, usizeOp, i8Op, i16Op, i32Op, i64Op, i128Op, isizeOp, i8Neg, i16Neg, i32Neg, i64Neg, i128Neg, isizeNeg, cast as ints_cast, convert, parses as ints_parses, widenings } from "./ints.ts";
@@ -293,18 +294,24 @@ export function cases(): [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec)
 		inline(data102, out103);
 	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::edges", (_2203: rt.u8, data103: rt.ByteSlice, out104: rt.ByteVec): undefined => {
 		elements_edges(data103, out104);
-	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::raw_slices", (_2204: rt.u8, data104: rt.ByteSlice, out105: rt.ByteVec): undefined => {
-		rawSlices(data104, out105);
-	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::empty_parts", (_2205: rt.u8, data105: rt.ByteSlice, out106: rt.ByteVec): undefined => {
-		emptyParts(data105, out106);
-	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::own", (_2206: rt.u8, data106: rt.ByteSlice, out107: rt.ByteVec): undefined => {
-		hashes_own(data106, out107);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["heap::spills", (_2204: rt.u8, data104: rt.ByteSlice, out105: rt.ByteVec): undefined => {
+		spills(data104, out105);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["heap::layouts", (_2205: rt.u8, data105: rt.ByteSlice, out106: rt.ByteVec): undefined => {
+		layouts(data105, out106);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["heap::remnants", (_2206: rt.u8, data106: rt.ByteSlice, out107: rt.ByteVec): undefined => {
+		remnants(data106, out107);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::raw_slices", (_2207: rt.u8, data107: rt.ByteSlice, out108: rt.ByteVec): undefined => {
+		rawSlices(data107, out108);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["elements::empty_parts", (_2208: rt.u8, data108: rt.ByteSlice, out109: rt.ByteVec): undefined => {
+		emptyParts(data108, out109);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["hashes::own", (_2209: rt.u8, data109: rt.ByteSlice, out110: rt.ByteVec): undefined => {
+		hashes_own(data109, out110);
 	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["refs::compared", (a0159: rt.u8, a1159: rt.ByteSlice, a2159: rt.ByteVec): undefined => {
 		compared(a0159, a1159.data, a1159.start, a1159.length, a2159);
 	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["rings::slices", (a0160: rt.u8, a1160: rt.ByteSlice, a2160: rt.ByteVec): undefined => {
 		rings_slices(a0160, a1160.data, a1160.start, a1160.length, a2160);
-	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::objects", (_2207: rt.u8, data107: rt.ByteSlice, out108: rt.ByteVec): undefined => {
-		fmt_objects(data107, out108);
+	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["fmt::objects", (_2210: rt.u8, data110: rt.ByteSlice, out111: rt.ByteVec): undefined => {
+		fmt_objects(data110, out111);
 	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::sorts", (a0161: rt.u8, a1161: rt.ByteSlice, a2161: rt.ByteVec): undefined => {
 		sorts(a0161, a1161.data, a1161.start, a1161.length, a2161);
 	}] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::disorders", disorders as (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined] as [string, (a0: rt.u8, a1: rt.ByteSlice, a2: rt.ByteVec) => undefined], ["sorts::btrees", (a0163: rt.u8, a1163: rt.ByteSlice, a2163: rt.ByteVec): undefined => {

ts/fixtures/lang/expected/heap.Fault.ts

@@ -0,0 +1,17 @@
+// Generated by rust2-ts. Do not edit.
+
+import * as rt from "./rt.ts";
+
+export function fmt$fmt_Debug(self: Fault, f: rt.Formatter): rt.Result<undefined, rt.FmtError> {
+	if (self.tag === "Overflow") {
+		return rt.fmtWriteStr(f, "Overflow");
+	}
+	const _6: string = "Alloc";
+	const _7: string = "layout";
+	const _8: rt.Fmt = (f: rt.Formatter) => rt.fmtLayoutDebug(self.layout, f);
+	return rt.debugStructFinish(rt.debugStructField(rt.fmtDebugStruct(f, _6), _7, _8));
+}
+
+export type Fault = { tag: "Overflow" } | { tag: "Alloc"; layout: rt.Layout };
+
+//# sourceMappingURL=heap.Fault.ts.map