@calcit/procs 0.13.9 → 0.13.11

package/editing-history/202608111322-agent-migration-convergence.md

@@ -0,0 +1,40 @@
+# Improve agent migration convergence
+
+Migrating Respo and its dependent modules to stricter Calcit types exposed a
+few CLI and compiler failures that made automated repairs unnecessarily slow or
+unsafe:
+
+- `cr edit imports` documented Cirru input but only accepted a single flat rule;
+  multi-rule input effectively required JSON.
+- Cirru transaction output expanded quoted empty lists into a shape that did not
+  round-trip, blocking safe insertion of zero-argument function definitions.
+- definition revision hashes rejected leaf-shaped examples/tests, so semantic
+  queries failed on otherwise valid definition-attached tests.
+- large but finite UI/Markdown dependency graphs overflowed the 16 MiB codegen
+  worker stack before diagnostics could identify the actual type errors.
+- several tree command help strings still advertised removed comma-separated
+  paths even though the parser requires `@2.1.0` coordinates.
+- concurrent mutation processes can overwrite each other's snapshot changes,
+  which was easy to trigger when an agent updated multiple entries in parallel.
+
+Changes:
+
+- Accept a quoted Cirru `[]` whose child expressions are import rules in
+  `cr edit imports`, while preserving JSON compatibility and rejecting
+  malformed flat children.
+- Emit inline Cirru for transaction quoted code so empty lists round-trip.
+- Give leaf examples/tests stable revision encodings without changing existing
+  list revision hashes.
+- Raise the dedicated codegen worker stack to 64 MiB, which is sufficient for
+  the current Respo UI/Markdown graph and still keeps recursion isolated from
+  the process main thread.
+- Align all path option help with the dot-separated coordinate parser.
+- Document that writes to one snapshot must be serialized, or grouped in a
+  revision-guarded transaction; independent snapshots/worktrees may still run
+  in parallel.
+
+Real-project validation used local Respo, Router, Markdown, UI, Reel, and Alerts
+snapshots after removing the obsolete Lilac module dependency. UI, Router, Reel,
+Alerts, and all three Markdown entries completed JS codegen. Calcit built-in
+tests passed 35/35 in Respo and 6/6 in Router; no external `calcit-test` runner
+was used.

package/editing-history/202608111349-release-0.13.10.md

@@ -0,0 +1,13 @@
+# Release 0.13.10
+
+Release the agent migration convergence improvements merged in PR #333:
+
+- quoted Cirru import-list input for `cr edit imports`;
+- safe transaction round-tripping for quoted empty lists;
+- revision support for leaf examples and definition-attached tests;
+- a larger codegen worker stack for finite real-world module graphs;
+- corrected tree path help and serialized snapshot mutation guidance.
+
+The changes were validated against the Respo dependency chain without Lilac or
+the external `calcit-test` module, in addition to the full Calcit Rust, native,
+JavaScript, agent-interface, and WASM gates.

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.9",
+    "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.9",
+  "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 => {