@calcit/procs 0.13.14 → 0.13.16

package/notes/repos.md

@@ -0,0 +1,177 @@
+# Calcit project repositories
+
+This inventory covers the repositories found under the configured local organization directories. The upgrade pass should fetch `origin/main`, inspect open PRs, and use the PR branch when one exists. Projects whose `deps.cirru` already declares Calcit `0.13.15` are skipped.
+
+## b-conf
+
+- `b-conf/conf-dates`
+- `b-conf/hestory`
+
+## calcit-lang
+
+- `calcit-lang/algebra`
+- `calcit-lang/apis`
+- `calcit-lang/bisection-key`
+- `calcit-lang/calcit-json`
+- `calcit-lang/calcit-lang.org`
+- `calcit-lang/clipboard`
+- `calcit-lang/code-viewer`
+- `calcit-lang/command`
+- `calcit-lang/convert-edn`
+- `calcit-lang/corokia`
+- `calcit-lang/docs-workflow`
+- `calcit-lang/dylib-workflow`
+- `calcit-lang/editor`
+- `calcit-lang/error-viewer`
+- `calcit-lang/explain-ternary-tree`
+- `calcit-lang/explore-quaternary`
+- `calcit-lang/fetch`
+- `calcit-lang/ffi-calx`
+- `calcit-lang/fswatch`
+- `calcit-lang/gen-code`
+- `calcit-lang/geometric`
+- `calcit-lang/graphviz`
+- `calcit-lang/guidebook`
+- `calcit-lang/http`
+- `calcit-lang/http-workflow`
+- `calcit-lang/ir-viewer`
+- `calcit-lang/jiuzhang-lang`
+- `calcit-lang/lilac`
+- `calcit-lang/lilac-guidebook`
+- `calcit-lang/lilac-parser`
+- `calcit-lang/memof`
+- `calcit-lang/migrate-calcit-class-record`
+- `calcit-lang/minimal-calcit`
+- `calcit-lang/paint`
+- `calcit-lang/phoenix-script`
+- `calcit-lang/quaternion`
+- `calcit-lang/reacher`
+- `calcit-lang/recollect`
+- `calcit-lang/regex`
+- `calcit-lang/repos-rank`
+- `calcit-lang/respo-calcit-workflow`
+- `calcit-lang/skir`
+- `calcit-lang/std`
+- `calcit-lang/std-old`
+- `calcit-lang/stir-template`
+- `calcit-lang/test`
+- `calcit-lang/wasi-calcit/examples`
+- `calcit-lang/wasm-play`
+- `calcit-lang/wasmtime`
+- `calcit-lang/workflow`
+- `calcit-lang/wss`
+
+## cirru
+
+- `cirru/calcit-editor`
+- `cirru/cirru.org`
+- `cirru/data-former`
+- `cirru/hovenia-editor`
+- `cirru/hv-tree-layout`
+- `cirru/jiuzhang-lang`
+- `cirru/respo-cirru-editor`
+- `cirru/text.cirru.org`
+- `cirru/theme`
+- `cirru/writer.clj`
+
+## cumulo
+
+- `cumulo/calcium-workflow`
+- `cumulo/cumulo-phlox-workflow`
+- `cumulo/cumulo-util.calcit`
+- `cumulo/cumulo.org`
+- `cumulo/display-latency`
+- `cumulo/reel`
+
+## memkits
+
+- `memkits/alcea-scribble`
+- `memkits/bullet-train`
+- `memkits/calc-dsl`
+- `memkits/color-pad`
+- `memkits/cyan-red`
+- `memkits/diary-viewer`
+- `memkits/diffview`
+- `memkits/edn-grid`
+- `memkits/edn-tree-viewer`
+- `memkits/garcinia-blocks`
+- `memkits/genai.calcit`
+- `memkits/geometry-book`
+- `memkits/hn-reader`
+- `memkits/in-time`
+- `memkits/life-patterns`
+- `memkits/lutea-reader`
+- `memkits/manuscript`
+- `memkits/markdown-editor`
+- `memkits/memkits.org`
+- `memkits/pick-name`
+- `memkits/poecilia-paint`
+- `memkits/poet-grab`
+- `memkits/proto-shuangpin`
+- `memkits/pudica-schedule`
+- `memkits/pudica-schedule-viewer`
+- `memkits/random-lives`
+- `memkits/sedum-slide`
+- `memkits/sky-chat`
+- `memkits/tco-redirect`
+- `memkits/timegrass-viewer`
+- `memkits/toadflax`
+- `memkits/unfolding-leaf`
+- `memkits/wanderlist`
+
+## mvc-works
+
+- `mvc-works/edn-formatter`
+- `mvc-works/fuzzy-filter`
+- `mvc-works/lilac-parser`
+- `mvc-works/pointed-prompt`
+- `mvc-works/text-diff`
+- `mvc-works/ws-edn.calcit`
+
+## respo
+
+- `respo/alerts`
+- `respo/example`
+- `respo/feather`
+- `respo/form.calcit`
+- `respo/guidebook`
+- `respo/markdown`
+- `respo/markup`
+- `respo/message`
+- `respo/reel`
+- `respo/respo`
+- `respo/respo-mvc.org`
+- `respo/router`
+- `respo/ui`
+- `respo/value`
+
+## tiye
+
+- `tiye/leaf-reading`
+- `tiye/neu-tab`
+- `tiye/tiye.me`
+
+## webgpu-art
+
+- `webgpu-art/lagopus`
+- `webgpu-art/lagopus-workflow`
+- `webgpu-art/lutra-crafts`
+- `webgpu-art/protea`
+- `webgpu-art/soluble`
+- `webgpu-art/syntax-cards`
+- `webgpu-art/wallpapers`
+- `webgpu-art/webgpu.art`
+
+## worktools
+
+- `worktools/camera-try`
+- `worktools/color-finder`
+- `worktools/color-ring`
+- `worktools/fontawesome-finder`
+- `worktools/mudder`
+- `worktools/qrcode-shelf`
+- `worktools/qrcode-toy-expo`
+- `worktools/rebase-hell`
+- `worktools/serve-json`
+- `worktools/snippet-splitter`
+- `worktools/walnut-log`

package/package.json

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

package/ts-src/calcit.procs.mts

@@ -1676,9 +1676,10 @@ export let parse_cirru_edn = (code: string, options: CalcitValue) => {
 };
 
 type DataShapeNode =
-  | { kind: "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" }
+  | { kind: "unit" | "bool" | "number" | "string" | "symbol" | "tag" | "buffer" | "cirru-quote" | "dynamic" }
   | { kind: "optional" | "list" | "set" | "ref"; inner: number }
   | { kind: "map"; key: number; value: number }
+  | { kind: "map-option"; nominal: CalcitEnumDef; inner: number }
   | { kind: "struct"; nominal: CalcitStructDef; fields: Array<[string, number]> }
   | { kind: "enum"; nominal: CalcitEnumDef; variants: Array<{ tag: string; payload: number[] }> };
 
@@ -1883,6 +1884,136 @@ export let parse_cirru_edn_as = (code: string, graph: DataShapeGraph): CalcitVal
   return decode_typed_edn_node(graph, graph.root, input, "$", 0) as CalcitValue;
 };
 
+const map_decode_error = (path: string, message: string): never => {
+  throw new Error(`decode-map-as failed at ${path}: ${message}`);
+};
+
+const decode_runtime_map_node = (graph: DataShapeGraph, nodeId: number, input: any, path: string, depth: number): any => {
+  if (depth > 1024) map_decode_error(path, "decode nesting exceeds 1024");
+  const node = graph.nodes[nodeId];
+  if (node == null) map_decode_error(path, `invalid data shape node #${nodeId}`);
+
+  switch (node.kind) {
+    case "dynamic":
+      return input;
+    case "map-option": {
+      if (
+        input instanceof CalcitEnumValue &&
+        (input.enumPrototype === node.nominal || input.enumPrototype?.name() === node.nominal.name())
+      ) {
+        const tag: CalcitValue = input.tag;
+        if (!(tag instanceof CalcitTag)) map_decode_error(path, "Option variant is not a tag");
+        const tag_name = (tag as CalcitTag).value;
+        if (tag_name === "none" && input.extra.length === 0) return input;
+        if (tag_name === "some" && input.extra.length === 1) {
+          return new CalcitEnumValue(tag as CalcitTag, [decode_runtime_map_node(graph, node.inner, input.extra[0], path, depth + 1)], node.nominal);
+        }
+        return map_decode_error(path, "invalid Option value");
+      }
+      return new CalcitEnumValue(newTag("some"), [decode_runtime_map_node(graph, node.inner, input, path, depth + 1)], node.nominal);
+    }
+    case "struct": {
+      if (!(input instanceof CalcitMap || input instanceof CalcitSliceMap)) {
+        return map_decode_error(path, `expected map for struct :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
+      }
+      const entries = new Map<string, any>();
+      input.pairs().forEach(([key, value]) => {
+        const name = key instanceof CalcitTag ? key.value : typeof key === "string" ? key : null;
+        if (name == null) map_decode_error(path, "struct map keys must be tags or strings");
+        if (!node.fields.some(([field]) => field === name)) {
+          map_decode_error(path, `struct :${node.nominal.name.value} has unknown field :${name}`);
+        }
+        if (entries.has(name)) map_decode_error(path, `struct :${node.nominal.name.value} has duplicate field :${name}`);
+        entries.set(name, value);
+      });
+      const decoded = new Map<string, any>();
+      node.fields.forEach(([field, child]) => {
+        if (entries.has(field)) {
+          decoded.set(field, decode_runtime_map_node(graph, child, entries.get(field), `${path}.${field}`, depth + 1));
+        } else {
+          const fieldNode = graph.nodes[child];
+          if (fieldNode?.kind === "map-option") {
+            decoded.set(field, new CalcitEnumValue(newTag("none"), [], fieldNode.nominal));
+          } else {
+            map_decode_error(path, `struct :${node.nominal.name.value} is missing required field :${field}`);
+          }
+        }
+      });
+      const values = node.nominal.fields.map((field) => decoded.get(field.value));
+      return new CalcitStructValue(node.nominal.name, node.nominal.fields, values, node.nominal);
+    }
+    case "list": {
+      if (!(input instanceof CalcitList || input instanceof CalcitSliceList)) {
+        return map_decode_error(path, `expected list, got ${typed_edn_kind(input)}`);
+      }
+      return new CalcitSliceList(Array.from(input.items()).map((value, idx) => decode_runtime_map_node(graph, node.inner, value, `${path}[${idx}]`, depth + 1)));
+    }
+    case "set": {
+      if (!(input instanceof CalcitSet || input instanceof TypedEdnSetView)) {
+        return map_decode_error(path, `expected set, got ${typed_edn_kind(input)}`);
+      }
+      const values: any[] = [];
+      const source = input instanceof TypedEdnSetView ? input.items : input.values();
+      source.forEach((value) => {
+        const decoded = decode_runtime_map_node(graph, node.inner, value, `${path}.item`, depth + 1);
+        if (values.some((item) => _$n__$e_(item, decoded))) map_decode_error(path, "duplicate decoded set value");
+        values.push(decoded);
+      });
+      return new CalcitSet(values);
+    }
+    case "map": {
+      if (!(input instanceof CalcitMap || input instanceof CalcitSliceMap)) {
+        return map_decode_error(path, `expected map, got ${typed_edn_kind(input)}`);
+      }
+      const entries: any[] = [];
+      input.pairs().forEach(([key, value]) => {
+        const decodedKey = decode_runtime_map_node(graph, node.key, key, `${path}.key`, depth + 1);
+        if (entries.some(([existing]) => _$n__$e_(existing, decodedKey))) map_decode_error(path, "duplicate decoded map key");
+        entries.push([decodedKey, decode_runtime_map_node(graph, node.value, value, `${path}.value`, depth + 1)]);
+      });
+      return new CalcitSliceMap(entries.flat());
+    }
+    case "optional":
+      return input == null ? null : decode_runtime_map_node(graph, node.inner, input, path, depth + 1);
+    case "ref":
+      if (!(input instanceof CalcitRef)) return map_decode_error(path, `expected atom, got ${typed_edn_kind(input)}`);
+      return atom(decode_runtime_map_node(graph, node.inner, input.value, `${path}.value`, depth + 1));
+    case "enum": {
+      if (!(input instanceof CalcitEnumValue) || input.enumPrototype == null) {
+        return map_decode_error(path, `expected enum :${node.nominal.name()}, got ${typed_edn_kind(input)}`);
+      }
+      const actualEnumName = enum_prototype_name(input.enumPrototype);
+      if (actualEnumName !== node.nominal.name()) {
+        return map_decode_error(path, `expected enum :${node.nominal.name()}, got enum :${actualEnumName}`);
+      }
+      if (!(input.tag instanceof CalcitTag)) return map_decode_error(path, `enum :${node.nominal.name()} variant must be a tag`);
+      const inputTag = input.tag as CalcitTag;
+      const variant = node.variants.find((candidate) => candidate.tag === inputTag.value);
+      if (variant == null) return map_decode_error(path, `enum :${node.nominal.name()} has no variant :${inputTag.value}`);
+      if (variant.payload.length !== input.extra.length) {
+        return map_decode_error(
+          path,
+          `enum :${node.nominal.name()} variant :${variant.tag} expects ${variant.payload.length} payload(s), got ${input.extra.length}`
+        );
+      }
+      const values = variant.payload.map((payloadNode, idx) =>
+        decode_runtime_map_node(graph, payloadNode, input.extra[idx], `${path}.payload[${idx}]`, depth + 1)
+      );
+      return new CalcitEnumValue(newTag(variant.tag), values, node.nominal);
+    }
+    default:
+      return decode_typed_edn_node(graph, nodeId, input, path, depth);
+  }
+};
+
+export let decode_map_as = (value: CalcitValue, graph: DataShapeGraph): CalcitValue => {
+  if (graph.version !== 1) throw new Error(`decode-map-as expected data shape ABI version 1, got ${graph.version}`);
+  if (typeof graph.fingerprint !== "string" || graph.fingerprint.length === 0) {
+    throw new Error("decode-map-as expected a non-empty data shape fingerprint");
+  }
+  return decode_runtime_map_node(graph, graph.root, value, "$", 0) as CalcitValue;
+};
+
 const json_to_calcit = (value: any): CalcitValue => {
   if (value == null) return null;
   if (typeof value === "string") return value;