@calcit/procs 0.13.41 → 0.13.43

package/editing-history/20260823-0401-guard-range-progress.md

@@ -0,0 +1,9 @@
+# Guard eager range construction
+
+- Capped eager range cardinality at the JavaScript array length limit in both
+  Native and JavaScript backends, returning the same controlled error before
+  iteration.
+- Detect floating-point steps that no longer change the current value, avoiding
+  infinite loops at large magnitudes.
+- Added Native regression coverage for oversized and non-advancing ranges; the
+  shared Calcit regression runs through Native and JavaScript integration suites.

package/editing-history/20260824-0318-range-backend-consistency.md

@@ -0,0 +1,13 @@
+# range backend consistency and allocation
+
+- Native and JavaScript `range` now reject non-finite inputs and use exact
+  equality for the empty half-open interval, avoiding divergent edge behavior.
+- JavaScript range generation handles negative steps and fills one backing
+  array directly instead of creating a new `CalcitSliceList` wrapper for every
+  item. A local 20 × 200,000-item benchmark improved from 40.96 ms to 20.71 ms.
+- Native range generation reserves the estimated vector capacity with
+  `try_reserve_exact`, retaining the existing iterative floating-point behavior
+  while avoiding repeated vector growth and reporting impossible allocations.
+- Regression coverage runs descending and fractional ranges in the native and
+  JavaScript project suites; definition-attached tests also cover descending
+  ranges in `calcit.core`.

package/editing-history/20260824-0645-unit-truthiness-review.md

@@ -0,0 +1,6 @@
+# Align Unit truthiness across runtimes
+
+- Treat `&unit` as false in native conditionals and `not`, matching JavaScript (`void 0`) and WebAssembly (`0`).
+- Make `or` use the shared conditional semantics, then add a Unit regression test.
+- Replace internal no-return `;nil` tails with `&unit`, while retaining `;nil` for legacy absence semantics.
+- Cover `json-stringify &unit` as a type error.

package/editing-history/20260824-0655-project-module-merge-review.md

@@ -0,0 +1,4 @@
+# Complete project-module merge review coverage
+
+- Avoid cloning a dependency snapshot when it has no namespaces owned by the project package.
+- Extend the transitive self-dependency regression to cover project subnamespaces and preserve strict conflicts for unrelated namespaces.

package/editing-history/20260824-0705-unit-effect-return-review.md

@@ -0,0 +1,5 @@
+# Complete Unit effect-return review
+
+- Document that `not` accepts Unit as a falsey input in its builtin help and core documentation.
+- Ensure `each` and `&doseq` discard callback or body values and return Unit for non-empty traversals.
+- Add definition-attached Unit regressions for both traversal helpers.

package/editing-history/20260824-1540-scaffold-data-kind-schema.md

@@ -0,0 +1,6 @@
+# Reconcile concrete data-definition schemas in scaffold plans
+
+- Accept an existing concrete `StructDef` or `EnumDef` schema when a scaffold plan declares the corresponding broad definition-kind marker.
+- Decode zero-payload canonical schema wrappers consistently at both snapshot-load and write-validation boundaries, avoiding their accidental interpretation as anonymous enum values.
+- Keep the compatibility rule directional and limited to data-definition schemas so unrelated function and value schemas remain strict.
+- Cover both struct and enum definition markers with a regression test.

package/editing-history/202608241335-skip-transitive-self-modules.md

@@ -0,0 +1,10 @@
+# Skip transitive copies of the project package
+
+- A project's direct dependency can reintroduce that same package through a
+  transitive dependency. Current namespace collision checks then rejected the
+  project source during normal compile and static-analysis commands.
+- Added a project-level merge path that drops only namespaces belonging to the
+  root package before applying the existing strict module merge. Direct module
+  conflict checks remain unchanged.
+- Added a regression test and verified the real respo-markdown project against
+  the current Respo dependency graph.

package/editing-history/202608241345-release-01342.md

@@ -0,0 +1,6 @@
+# Release 0.13.42
+
+- Publish the project-module merge fix from PR #404.
+- This permits a library to validate itself when a direct dependency includes
+  the same package transitively, while preserving strict cross-package module
+  conflicts.

package/editing-history/202608241525-release-01343.md

@@ -0,0 +1,5 @@
+# Release 0.13.43
+
+- Align Unit truthiness across native, JavaScript, and WASM runtimes.
+- Reconcile existing `StructDef` and `EnumDef` definitions with matching scaffold architecture markers.
+- Include the range backend consistency and performance improvements merged after 0.13.42.

package/lib/calcit.procs.d.mts

@@ -139,7 +139,7 @@ export declare let _$n_map_$o_dissoc: (xs: CalcitValue, ...args: CalcitValue[])
 export declare let reset_$x_: (a: CalcitRef, v: CalcitValue) => null;
 export declare let add_watch: (a: CalcitRef, k: CalcitTag, f: CalcitFn) => null;
 export declare let remove_watch: (a: CalcitRef, k: CalcitTag) => null;
-export declare let range: (n: number, m: number, step?: number) => CalcitSliceList | CalcitList;
+export declare let range: (n: number, m?: number, step?: number) => CalcitSliceList;
 export declare function _$n_list_$o_empty_$q_(xs: CalcitValue): boolean;
 export declare function _$n_str_$o_empty_$q_(xs: CalcitValue): boolean;
 export declare function _$n_map_$o_empty_$q_(xs: CalcitValue): boolean;

package/lib/calcit.procs.mjs

@@ -802,23 +802,48 @@ export let remove_watch = (a, k) => {
     a.listeners.delete(k);
     return null;
 };
+const MAX_RANGE_LENGTH = 4294967295;
 export let range = (n, m, step = 1) => {
-    var result = new CalcitSliceList([]);
-    if (m != null) {
-        var idx = n;
-        while (idx < m) {
-            result = result.append(idx);
-            idx = idx + step;
+    const base = m == null ? 0 : n;
+    const bound = m == null ? n : m;
+    if (!Number.isFinite(base) || !Number.isFinite(bound) || !Number.isFinite(step)) {
+        throw new TypeError("&list:range expected finite numbers for base, bound, and step");
+    }
+    if (base === bound) {
+        return new CalcitSliceList([]);
+    }
+    if (step === 0 || (bound > base && step < 0) || (bound < base && step > 0)) {
+        throw new Error("&list:range cannot construct list with a step of 0 or invalid step direction");
+    }
+    // Avoid overflowing `bound - base` when finite endpoints have opposite signs.
+    const estimatedLength = (base < 0) !== (bound < 0)
+        ? Math.ceil(Math.abs(base) / Math.abs(step) + Math.abs(bound) / Math.abs(step))
+        : Math.ceil((bound - base) / step);
+    if (!Number.isFinite(estimatedLength) || estimatedLength > MAX_RANGE_LENGTH) {
+        throw new Error("&list:range result is too large");
+    }
+    const result = [];
+    if (step > 0) {
+        for (let value = base; value < bound;) {
+            result.push(value);
+            const next = value + step;
+            if (next === value) {
+                throw new Error("&list:range step does not advance the current value");
+            }
+            value = next;
         }
     }
     else {
-        var idx = 0;
-        while (idx < n) {
-            result = result.append(idx);
-            idx = idx + step;
+        for (let value = base; value > bound;) {
+            result.push(value);
+            const next = value + step;
+            if (next === value) {
+                throw new Error("&list:range step does not advance the current value");
+            }
+            value = next;
         }
     }
-    return result;
+    return new CalcitSliceList(result);
 };
 export function _$n_list_$o_empty_$q_(xs) {
     if (xs instanceof CalcitList || xs instanceof CalcitSliceList)

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.13.41",
+    "version": "0.13.43",
     "main": "./lib/calcit.procs.mjs",
     "devDependencies": {
         "@types/node": "^25.7.0",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.13.41",
+  "version": "0.13.43",
   "main": "./lib/calcit.procs.mjs",
   "devDependencies": {
     "@types/node": "^25.7.0",

package/ts-src/calcit.procs.mts

@@ -889,22 +889,51 @@ export let remove_watch = (a: CalcitRef, k: CalcitTag): null => {
   return null;
 };
 
-export let range = (n: number, m: number, step: number = 1): CalcitSliceList | CalcitList => {
-  var result: CalcitList | CalcitSliceList = new CalcitSliceList([]);
-  if (m != null) {
-    var idx = n;
-    while (idx < m) {
-      result = result.append(idx);
-      idx = idx + step;
+const MAX_RANGE_LENGTH = 0xffff_ffff;
+
+export let range = (n: number, m?: number, step: number = 1): CalcitSliceList => {
+  const base = m == null ? 0 : n;
+  const bound = m == null ? n : m;
+
+  if (!Number.isFinite(base) || !Number.isFinite(bound) || !Number.isFinite(step)) {
+    throw new TypeError("&list:range expected finite numbers for base, bound, and step");
+  }
+  if (base === bound) {
+    return new CalcitSliceList([]);
+  }
+  if (step === 0 || (bound > base && step < 0) || (bound < base && step > 0)) {
+    throw new Error("&list:range cannot construct list with a step of 0 or invalid step direction");
+  }
+
+  // Avoid overflowing `bound - base` when finite endpoints have opposite signs.
+  const estimatedLength = (base < 0) !== (bound < 0)
+    ? Math.ceil(Math.abs(base) / Math.abs(step) + Math.abs(bound) / Math.abs(step))
+    : Math.ceil((bound - base) / step);
+  if (!Number.isFinite(estimatedLength) || estimatedLength > MAX_RANGE_LENGTH) {
+    throw new Error("&list:range result is too large");
+  }
+
+  const result: Array<CalcitValue> = [];
+  if (step > 0) {
+    for (let value = base; value < bound; ) {
+      result.push(value);
+      const next = value + step;
+      if (next === value) {
+        throw new Error("&list:range step does not advance the current value");
+      }
+      value = next;
     }
   } else {
-    var idx = 0;
-    while (idx < n) {
-      result = result.append(idx);
-      idx = idx + step;
+    for (let value = base; value > bound; ) {
+      result.push(value);
+      const next = value + step;
+      if (next === value) {
+        throw new Error("&list:range step does not advance the current value");
+      }
+      value = next;
     }
   }
-  return result;
+  return new CalcitSliceList(result);
 };
 
 export function _$n_list_$o_empty_$q_(xs: CalcitValue): boolean {