@calcit/procs 0.13.10 → 0.13.11

package/history/202608111550-trailing-option-parameters.md

@@ -0,0 +1,6 @@
+## Trailing Option parameters
+
+- Treat only the continuous `Option<T>` suffix in a typed fixed-arity function schema as omittable; an earlier `Option<T>` does not make later required parameters optional, and rest parameters keep their existing behavior.
+- Fill omitted arguments with the nominal `calcit.core/Option` `%none` value in the native runtime and with the matching `%none` enum value in generated JavaScript.
+- Keep preprocessing arity checks and method-call validation aligned with runtime behavior so accepted calls do not produce false arity diagnostics.
+- Consolidate the end-to-end coverage beside the legacy `?` argument tests, documenting `Option` as the preferred replacement for `?` and `nil` in new typed APIs.

package/history/202608111610-review-core-option-identity.md

@@ -0,0 +1,5 @@
+## Review follow-up: core Option identity
+
+- Omitted-argument sugar is reserved for source references to `calcit.core/Option`; resolved enum values do not retain a namespace and therefore cannot be safely treated as the core type.
+- A user-defined enum named `Option`, including one with `some` and `none` variants, keeps exact arity and never receives an implicit `%none` argument.
+- Documentation examples use callable enum constructors: `(%none)` and `(%some value)`.

package/history/202608111624-js-string-replace-termination.md

@@ -0,0 +1,5 @@
+## JS string replacement termination
+
+- `&str:replace` must replace each original literal match exactly once; repeatedly replacing until the pattern disappears loops forever when the replacement contains the pattern.
+- Escape the literal pattern and use a global callback replacement so replacement text remains literal too, including `$` sequences.
+- Keep empty-pattern behavior aligned with Rust `str::replace`, and cover self-containing replacements, regex metacharacters, literal replacement text, and empty patterns in the JS runtime regression script.

package/history/202608111650-release-0.13.11.md

@@ -0,0 +1,5 @@
+## Release 0.13.11
+
+- Bump the Cargo crate and `@calcit/procs` package together so published artifacts stay version-aligned.
+- This release includes trailing `Option` parameter sugar, stronger typed Option/struct handling, and the terminating JS string replacement fix from the preceding merged PRs.
+- Run the full repository validation before tagging and publishing the release.

package/lib/calcit.procs.mjs

@@ -1216,11 +1216,11 @@ export let _$n_set_$o_intersection = (xs, ys) => {
     return xs.intersection(ys);
 };
 export let _$n_str_$o_replace = (x, y, z) => {
-    var result = x;
-    while (result.indexOf(y) >= 0) {
-        result = result.replace(y, z);
-    }
-    return result;
+    // Use a callback replacement so `$` sequences in `z` remain literal, matching Rust's
+    // `str::replace`. Escaping `y` preserves the proc's literal-pattern contract, while the
+    // global regex completes each original match once even when `z` contains `y`.
+    const literalPattern = y.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return x.replace(new RegExp(literalPattern, "gu"), () => z);
 };
 export let split = (xs, x) => {
     return new CalcitSliceList(xs.split(x));

package/lib/package.json

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

package/package.json

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

package/ts-src/calcit.procs.mts

@@ -1329,11 +1329,11 @@ export let _$n_set_$o_intersection = (xs: CalcitSet, ys: CalcitSet): CalcitSet =
 };
 
 export let _$n_str_$o_replace = (x: string, y: string, z: string): string => {
-  var result = x;
-  while (result.indexOf(y) >= 0) {
-    result = result.replace(y, z);
-  }
-  return result;
+  // Use a callback replacement so `$` sequences in `z` remain literal, matching Rust's
+  // `str::replace`. Escaping `y` preserves the proc's literal-pattern contract, while the
+  // global regex completes each original match once even when `z` contains `y`.
+  const literalPattern = y.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  return x.replace(new RegExp(literalPattern, "gu"), () => z);
 };
 
 export let split = (xs: string, x: string): CalcitSliceList => {