feat(ts): split a deque's slices where std's are, and translate their Debug

quest/m3/README.md

@@ -32,7 +32,8 @@ generic std gap is planned here even when moq never calls it.
 - [A closure that drops given to a string's edit or search](/quest/m3/ts-string-closures.md) - `String::retain` and `str`'s searches by a closure that owns a value that drops translate
 - [Waiting: a slice object for a mutable part of other values](/quest/m3/ts-slice-object.md) - waits on a moq profile showing the `Proxy` view's traps matter, then decides on an `rt.ByteSlice`-like form
 - [Port the workflow guard to kixelated/quest](/quest/m3/quest-workflow-guard.md) - quest's environment guard parses YAML as this repository's does
-- [A deque's two slices](/quest/m3/ts-deque-slices.md) - `VecDeque::as_slices` and `{:?}` of a deque's `Iter`, `IterMut`, and `Drain` translate, split where std's are
+- [A comparison of two constants](/quest/m3/ts-constant-compares.md) - `size_of::<T>() == 1` in a generic function translates to TypeScript `tsc` accepts
+- [A vector's exact capacity as it shrinks](/quest/m3/ts-vec-exact-capacity.md) - a deque made from a `Vec` splits its slices where std's does
 - [A B-tree's searches call Ord as std's do](/quest/m3/ts-btree-search-order.md) - a B-tree's lookups and inserts call a key's own `Ord` in std's order and number
 - [Rc and Arc of a slice](/quest/m3/ts-shared-slices.md) - `Rc<[T]>` and `Arc<[T]>` from a `Vec`, a slice, or an iterator translate
 - [The rest of a vector's methods](/quest/m3/ts-vec-rest.md) - `append`, `resize`, `split_off`, `try_reserve`, and `Vec::from(VecDeque)` translate

quest/m3/ts-constant-compares.md

@@ -0,0 +1,18 @@
+# [S] A comparison of two constants
+
+## Goal
+
+[rust2-ts](/ts/README.md) translates a comparison whose sides are both constants once a
+generic function is monomorphized, such as `size_of::<T>() == 1` in a function generic
+over `T`, into TypeScript `tsc` accepts, proven by a fixture that runs it for a `T` of each
+outcome against native Rust.
+
+## Plan
+
+Found writing the deque's slices fixture
+([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): each instance writes
+`12 === 1`, which `tsc` rejects as TS2367, two literal types with no overlap, so the
+crate fails to translate. Fold the comparison to its value, or widen a side, where both are
+literals.
+
+Public API: the translator's output.

quest/m3/ts-vec-exact-capacity.md

@@ -0,0 +1,27 @@
+# [M] A vector's exact capacity as it shrinks
+
+## Goal
+
+[rust2-ts](/ts/README.md) holds a `Vec`'s exact capacity through every step, as it now
+does a `VecDeque`'s, so a deque made from a `Vec` splits its slices where std's does,
+proven by differential tests against native Rust.
+
+## Plan
+
+Found splitting a deque's slices where std's does
+([moq-dev/rust2#443](https://github.com/moq-dev/rust2/pull/443)): a deque now holds std's
+exact capacity, but one made from a `Vec`, by `From<Vec<T>>` or by `collect`, takes the
+capacity the runtime models for the `Vec`, which holds only std's guarantees (decided
+2026-11-01) and so recomputes from its length after a pop, `truncate`, or `drain`. A
+`Vec<u8>` already holds its exact capacity as its buffer's length.
+
+- Recording the capacity on the array where a step shrinks the length (a `peak` each pop
+  raises) was measured on `push/stack`, which pushes onto a `Vec`, popping one every
+  fourth push, then pops it empty: 1.24x in Node, 1.11x in Chrome, 2.3x in Bun, and 2.8x
+  in Firefox, every other workload within noise. The maintainer kept the guarantee-only
+  model on 2026-11-02, accepting that a deque made from a shrunk `Vec` may split
+  differently from std's.
+- Untried: a `Vec` as a wrapper object holding its own length and capacity over its
+  array, measured on the same workload before it is weighed against that decision.
+
+Public API: the translator's output.

ts/MIGRATE.md

@@ -18,11 +18,20 @@
   through `rt.hashI8` to `rt.hashI128`, `rt.hashUsize`, or `rt.hashIsize`, as its Rust
   impl calls `write_i8` and the rest. `rt.hashOne` takes the hasher it hashes into, as in
   `rt.hashOne(rt.buildHasher(state), value, hash)`.
-- `rt.vecCapacity`, `rt.vecReserve`, `rt.vecReserveExact`, and `rt.dequeReserve` are now
-  `Vec::capacity`, `reserve`, and `reserve_exact` and `VecDeque::reserve` of a vector, its
-  element size in bytes last, as in `rt.vecReserve(v, additional, 4)`, not the arithmetic
-  an extend reserved by; `rt.vecPush` and `rt.vecGrow` are gone. `rt.dequeClone` and
-  `rt.heapClone` take the element size after the clone function.
+- `rt.vecCapacity`, `rt.vecReserve`, and `rt.vecReserveExact` are now `Vec::capacity`,
+  `reserve`, and `reserve_exact` of a vector, its element size in bytes last, as in
+  `rt.vecReserve(v, additional, 4)`, not the arithmetic an extend reserved by;
+  `rt.vecPush` and `rt.vecGrow` are gone. `rt.heapClone` takes the element size after the
+  clone function.
+- `rt.vecExtendFromSlice` takes the element size in bytes after the slice, as in
+  `rt.vecExtendFromSlice(v, s, 4)`. `rt.iterToArray` and `rt.iterToByteVec` take the
+  source element size of a `collect` that may reuse its source's buffer last.
+- An `rt.VecDeque` holds std's capacity as its buffer's length and its item size as `s`,
+  and a deque of bytes is a `Uint8Array`: `rt.dequeNew`, `rt.dequeWithCapacity`, and
+  `rt.dequeFromVec` take the item size and whether it holds bytes, as in
+  `rt.dequeNew(4)`, and `rt.dequeCapacity`, `rt.dequeReserve`, `rt.dequeReserveExact`,
+  `rt.dequeShrinkTo`, `rt.dequeClone`, `rt.dequeExtend`, and `rt.dequePart` no longer take
+  it. `rt.dequeIter` no longer takes a dropper: `rt.dequeIntoIter` is `into_iter`.
 - Every translation needs `tsc` 7.0 or later on `PATH`, not only one with bindings: it
   type-checks the output, and fails at the Rust span of each error, where it succeeded
   before.

ts/README.md

@@ -249,9 +249,9 @@ what each holds. `Debug` of a string or `char` escapes by
 std's Unicode tables, which the runtime carries, not the engine's. `Debug` of std's
 collections writes their items in the order each iterates, a hash map's or set's included,
 and of their iterators and `Chars` the items each has left, in std's wrapper; a deque's
-`Iter` and `IterMut`, which write its buffer's two halves, and its `Drain`, which writes its
-counts, are refused; a list's `Iter` and `IterMut` write what is left and its length, as
-std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is
+`Iter` and `IterMut` write the two slices of its buffer they have left, swapped as std's
+swap them, and its `Drain` its counts; a list's `Iter` and `IterMut` write what is left and
+its length, as std's do. `Debug` of `Bound`, `Ordering`, `Reverse`, and `ControlFlow` is
 their derived one, whichever way each is held, and a guard of a cell or a lock, mapped or
 not, writes what it lends by its own `Debug` and `Display`. A caller prints a
 `printable` type as `to_string()` and `format!("{err:?}")`
@@ -792,11 +792,14 @@ they need.
   with the maintainer on 2026-11-01). It holds one, as `cap`, only where an operation
   sets it or a removal reads it, so an insert never reads or writes one, and reading it
   doubles it from 3 while short of the length. `VecDeque` is a ring buffer over an array
-  whose length is a power of two. A `Vec`, `VecDeque`, and `BinaryHeap` hold what std
+  whose length is std's capacity, a `Uint8Array` of bytes, and each step places its items
+  where std's does, so `as_slices` splits them as std's; one made from a `Vec` takes the
+  capacity held for the `Vec`. A `Vec` and `BinaryHeap` hold what std
   guarantees of their capacity: at least their length and what `with_capacity`,
   `reserve`, and `reserve_exact` ask for, and std's exactly where its doubling fixes it,
-  as through pushes. `clone_from` and `clone_into`, of which std guarantees only the
-  length, leave a clone's capacity, not the allocation std reuses. One holds a capacity, as `cap`, only where `with_capacity`, `reserve`,
+  as through pushes, a `clone_from` into a `Vec` that keeps its own, and a `collect` that
+  reuses its source's buffer, in place or from a boxed slice, whose capacity is its
+  length. One holds a capacity, as `cap`, only where `with_capacity`, `reserve`,
   `shrink_to`, a `clone`, or a `collect` or `extend` set it, so a push never reads or
   writes one. Reading it doubles it while short of the length, from the least std's
   `RawVec` allocates for the element size, which a run of pushes grows std's to. A

ts/fixtures/codec/expected/bench.ts

@@ -443,7 +443,7 @@ export function push(selector: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void
 	let _37!: rt.u32;
 	const count2: rt.u32 = rt.u64Low(rt.u64Min(takeU64(data)[0], 65536));
 	if (selector === 1) {
-		const q: rt.VecDeque<rt.u32> = rt.dequeNew() as rt.VecDeque<rt.u32>;
+		const q: rt.VecDeque<rt.u32> = rt.dequeNew(4) as rt.VecDeque<rt.u32>;
 		let iterStart: rt.u32 = 0;
 		const iterEnd: rt.u32 = count2;
 		while ((_18 = iterStart++) < iterEnd) {

ts/fixtures/lang/caller.ts

@@ -868,13 +868,13 @@ const gets = [0, 0x10].flatMap((text) => {
  * it tries.
  */
 const capacityCases = [
-	...[["capacity::vecs", 25], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) =>
+	...[["capacity::vecs", 29], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) =>
 		Array.from({ length: 5 * 2 * (steps as number) * 4 }, (_, i) => {
 			const [kind, first, step, arg] = [i % 5, (Math.floor(i / 5) % 2) * 0x11, Math.floor(i / 10) % (steps as number), [3, 0xc1, 0xe3, 0x16][Math.floor(i / (10 * (steps as number)))]];
 			return Uint8Array.of(...op(name as string), kind, first, ...[0, 1, 0, 2, 0, 3, 0, 4, 0, 5].map((b, j) => (j % 2 === 0 ? b : b * 41)), step, arg, step, arg ^ 1);
 		}),
 	),
-	...[["capacity::vecs", 25], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) =>
+	...[["capacity::vecs", 29], ["capacity::deques", 21], ["capacity::heaps", 13]].flatMap(([name, steps]) =>
 		Array.from({ length: 5 * 2 * (steps as number) }, (_, i) => Uint8Array.of(...op(name as string), i % 5, 0, 0, 1, 3 + (Math.floor(i / 5) % 2), 3, Math.floor(i / 10), 0)),
 	),
 	...["capacity::vecs", "capacity::deques", "capacity::heaps"].flatMap((name) =>
@@ -884,6 +884,31 @@ const capacityCases = [
 	...Array.from({ length: 8 * 6 }, (_, i) => Uint8Array.of(...op("capacity::collects"), i % 8, [0, 1, 2, 5, 9, 23][Math.floor(i / 8)], 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)),
 ];
 
+/**
+ * `rings::slices` of each item type, from a deque made by `new`, `with_capacity` of 5, and
+ * from a `Vec` of 7: pushed at both ends and popped at the front to wrap it, past a few
+ * capacities, then each step by a few arguments, twice.
+ */
+const ringsCases = Array.from({ length: 5 * 3 * 4 * 24 * 3 }, (_, i) => {
+	const [kind, first, wraps, step, arg] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15) % 4], Math.floor(i / 60) % 24, [0, 0x5b, 0xe7][Math.floor(i / 1440)]];
+	const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat();
+	return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, step, arg, step, arg ^ 0x25);
+});
+
+/**
+ * `rings::slices` remaking each wrapped deque each way and with a few skips: a clone,
+ * `clone_from`, `clone_into`, its `into_iter` read in part and by `nth`, from a `Vec` as it
+ * is and filtered in place, and a `Vec`'s `into_iter` read in part, collected as it is and
+ * cloned; then pushed at both ends.
+ */
+const remadeCases = [0, 5, 0x2d, 0x37, 0x64, 0x6e, 1, 0x10, 2, 0x11, 3, 0x21, 0x0e, 0x13, 0x45, 0x5f].flatMap((arg) =>
+	Array.from({ length: 5 * 3 * 4 }, (_, i) => {
+		const [kind, first, wraps] = [i % 5, [0, 0x15, 0x1e][Math.floor(i / 5) % 3], [1, 3, 6, 10][Math.floor(i / 15)]];
+		const wrap = Array.from({ length: wraps }, (_, j) => [j % 3 === 2 ? 4 : 0, j * 3, 6, 0, 4, j]).flat();
+		return Uint8Array.of(...op("rings::slices"), kind, first, ...wrap, 22, arg, 0, 9, 4, 9);
+	}),
+);
+
 /**
  * `sorts` cases of each length std's thresholds part, of each run of keys; `disorders`
  * cases of each length, kind of item, and sort; and `btrees` cases of each length.
@@ -894,4 +919,4 @@ const sortCases = [
 	...Array.from({ length: 20 * 5 }, (_, i) => Uint8Array.of(...op("sorts::btrees"), i % 20, Math.floor(i / 20), 2, 9)),
 ];
 
-export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...placeCompares, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...sortCases];
+export const cases: Uint8Array[] = [...loops, ...durations, ...ints(), ...utf8, ...floats, ...formats, ...parsed, ...singlesCases, ...singlesFormats, ...singlesParsed, ...dyns, ...cells, ...shared, ...locks, ...guards, ...maps, ...mappedLocks, ...relocks, ...tries, ...mutexMaps, ...printed, ...downgrades, ...leaks, ...placeCompares, ...rwlocks, ...onces, ...bounds, ...unsafeCells, ...edits, ...subslices, ...consumers, ...closures, ...elements, ...ranges, ...reducers, ...sliceEdits, ...drains, ...iters, ...hinted, ...peekedOthers, ...hints, ...reserves, ...setOps, ...zeros, ...writes, ...floatsMulAdds, ...singlesMulAdds, ...unlikeEqs, ...ownNes, ...rangeFroms, ...compares, ...unlikeCompares, ...rangeMethods, ...wraps(), ...refOrders, ...saturates(), ...methods(), ...separated, ...asciiCases, ...gets, ...capacityCases, ...ringsCases, ...remadeCases, ...sortCases];

ts/fixtures/lang/expected/bounds.ts

@@ -179,7 +179,7 @@ export function bounds(kind: rt.u8, data: rt.ByteSlice, out: rt.ByteVec): void {
 			flush(out);
 			rt.iterExtendBytes(out, rt.iterSlice(rt.byteVecView(bytes2)), undefined, true);
 		} else if (_28 === 2) {
-			const queue: rt.VecDeque<bounds_Item.Item> = rt.dequeNew() as rt.VecDeque<bounds_Item.Item>;
+			const queue: rt.VecDeque<bounds_Item.Item> = rt.dequeNew(1) as rt.VecDeque<bounds_Item.Item>;
 			const iter2: rt.Iter<[rt.usize, rt.u8]> = rt.iterEnumerate(rt.iterSlice(rt.byteSliceView(rt.byteSliceRange(data, 4))));
 			while (true) {
 				const _104: [rt.usize, rt.u8] | rt.Done = iter2.next();