@calcit/procs 0.29.0-alpha.27 → 0.29.0-alpha.29

package/lib/calcit-data.d.mts

@@ -37,6 +37,7 @@ export declare let newTag: (content: string) => CalcitTag;
 export declare let castTag: (x: CalcitValue) => CalcitTag;
 export declare var refsRegistry: Map<string, CalcitRef>;
 export declare let hashFunction: (x: CalcitValue) => Hash;
+export declare let format_calcit_number: (x: number) => string;
 export declare let toString: (x: CalcitValue, escaped: boolean, disableJsDataWarning?: boolean) => string;
 export declare let to_js_data: (x: CalcitValue, options?: CalcitValue) => any;
 export declare let _$n_map_$o_get: (xs: CalcitValue, k: CalcitValue) => CalcitValue;

package/lib/calcit-data.mjs

@@ -447,6 +447,38 @@ let hashCirru = (base, x) => {
 };
 // Dirty code to change ternary-tree behavior
 overwriteHashGenerator(hashFunction);
+// Calcit number text, shared by `turn-string`, `str` and printing (see docs/data/number.md).
+export let format_calcit_number = (x) => {
+    // Match native f64 Display, which expands finite exponents into decimal notation.
+    if (Object.is(x, -0)) {
+        return "-0";
+    }
+    if (x === Infinity) {
+        return "inf";
+    }
+    if (x === -Infinity) {
+        return "-inf";
+    }
+    const text = x.toString();
+    const exponentIndex = text.indexOf("e");
+    if (exponentIndex < 0) {
+        return text;
+    }
+    const mantissa = text.slice(0, exponentIndex);
+    const exponent = Number(text.slice(exponentIndex + 1));
+    const sign = mantissa.startsWith("-") ? "-" : "";
+    const unsigned = sign ? mantissa.slice(1) : mantissa;
+    const decimalPoint = unsigned.indexOf(".");
+    const decimalIndex = (decimalPoint < 0 ? unsigned.length : decimalPoint) + exponent;
+    const digits = unsigned.replace(".", "");
+    if (decimalIndex <= 0) {
+        return `${sign}0.${"0".repeat(-decimalIndex)}${digits}`;
+    }
+    if (decimalIndex >= digits.length) {
+        return `${sign}${digits}${"0".repeat(decimalIndex - digits.length)}`;
+    }
+    return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
+};
 export let toString = (x, escaped, disableJsDataWarning = false) => {
     if (x === null) {
         return "nil";
@@ -468,7 +500,7 @@ export let toString = (x, escaped, disableJsDataWarning = false) => {
         }
     }
     if (typeof x === "number") {
-        return x.toString();
+        return format_calcit_number(x);
     }
     if (typeof x === "boolean") {
         return x.toString();

package/lib/calcit.procs.d.mts

@@ -398,7 +398,7 @@ export declare let macroexpand_all: () => void;
 export declare let _$n_get_calcit_running_mode: () => void;
 export declare let _$n_get_def_doc: () => void;
 export declare let _$n_get_def_schema: () => void;
-export declare let _$n_ffi_response_resolve: () => void;
-export declare let _$n_ffi_response_reject: () => void;
-export declare let _$n_ffi_task_cancel: () => void;
+export declare let _$n_ffi_response_resolve: (..._args: CalcitValue[]) => never;
+export declare let _$n_ffi_response_reject: (..._args: CalcitValue[]) => never;
+export declare let _$n_ffi_task_cancel: (..._args: CalcitValue[]) => never;
 export declare let raise: () => void;

package/lib/calcit.procs.mjs

@@ -3,7 +3,7 @@ export const calcit_version = pkg.version;
 export const calcit_package_json = pkg;
 import { parse } from "@cirru/parser.ts";
 import { writeCirruCode } from "@cirru/writer.ts";
-import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, getStringName, compareTagNames, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
+import { CalcitSymbol, CalcitTag, CalcitRecur, castTag, newTag, refsRegistry, toString, format_calcit_number, getStringName, compareTagNames, _$n__$e_, hashFunction, } from "./calcit-data.mjs";
 import { CalcitRef, atom } from "./js-ref.mjs";
 import { CalcitStructValue } from "./js-struct-value.mjs";
 import { CalcitImpl } from "./js-impl.mjs";
@@ -946,7 +946,9 @@ export let remove_watch = (a, k) => {
     }
     throw new Error(`remove-watch failed: listener with key \`${k.value}\` not found`);
 };
-const MAX_RANGE_LENGTH = 4294967295;
+// Same eager range limit as native `MAX_RANGE_LEN` and WASM, 2^24 elements (#1852).
+const MAX_RANGE_LENGTH = 2 ** 24;
+const rangeTooLarge = () => new Error(`&list:range result is too large: more than ${MAX_RANGE_LENGTH} elements`);
 export let range = (n, m, step = 1) => {
     const base = m == null ? 0 : n;
     const bound = m == null ? n : m;
@@ -964,11 +966,13 @@ export let range = (n, m, step = 1) => {
         ? 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");
+        throw rangeTooLarge();
     }
     const result = [];
     if (step > 0) {
         for (let value = base; value < bound;) {
+            if (result.length >= MAX_RANGE_LENGTH)
+                throw rangeTooLarge();
             result.push(value);
             const next = value + step;
             if (next === value) {
@@ -979,6 +983,8 @@ export let range = (n, m, step = 1) => {
     }
     else {
         for (let value = base; value > bound;) {
+            if (result.length >= MAX_RANGE_LENGTH)
+                throw rangeTooLarge();
             result.push(value);
             const next = value + step;
             if (next === value) {
@@ -1158,11 +1164,12 @@ export let _$n_list_$o_slice = (xs, from, to) => {
     if (to == null) {
         to = size;
     }
-    else if (to <= from) {
-        return new CalcitSliceList([]);
+    // Bounds are integers with 0 <= from <= to <= size, as in native (docs/data/number.md).
+    if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || from > to || to > size) {
+        throw new Error(`&list:slice expected integer bounds within 0..${size}, but received: ${from} ${to}`);
     }
-    else if (to > size) {
-        to = size;
+    if (from === to) {
+        return new CalcitSliceList([]);
     }
     return xs.slice(from, to);
 };
@@ -1360,13 +1367,19 @@ export let cos = (n) => {
     return Math.cos(n);
 };
 export let pow = (n, m) => {
+    // IEEE 754 pow, which Math.pow breaks: pow(1, y) is 1 for any y, pow(-1, ±Infinity) is 1.
+    if (n === 1 || (n === -1 && (m === Infinity || m === -Infinity))) {
+        return 1;
+    }
     return Math.pow(n, m);
 };
 export let ceil = (n) => {
     return Math.ceil(n);
 };
 export let round = (n) => {
-    return Math.round(n);
+    // Ties round away from zero; `Math.round` alone rounds them toward +Infinity.
+    // Negating keeps `-0` for inputs such as -0.4.
+    return n < 0 ? -Math.round(-n) : Math.round(n);
 };
 export let _$n_number_$o_fract = (n) => {
     return n - Math.floor(n);
@@ -1519,6 +1532,10 @@ export let _$n_number_$o_format = (x, n) => {
     return x.toFixed(n);
 };
 export let _$n_number_$o_display_by = (x, n) => {
+    // a non-negative safe integer, printed exactly (docs/data/number.md)
+    if (typeof x !== "number" || !Number.isSafeInteger(x) || x < 0) {
+        throw new Error(`&number:display-by expected a non-negative safe integer, but received: ${x}`);
+    }
     switch (n) {
         case 2:
             return `0b${x.toString(2)}`;
@@ -1690,37 +1707,6 @@ export let quit_$x_ = (code) => {
         throw new Error(`quit!(${code})`);
     }
 };
-let format_calcit_number = (x) => {
-    // Match native f64 Display, which expands finite exponents into decimal notation.
-    if (Object.is(x, -0)) {
-        return "-0";
-    }
-    if (x === Infinity) {
-        return "inf";
-    }
-    if (x === -Infinity) {
-        return "-inf";
-    }
-    const text = x.toString();
-    const exponentIndex = text.indexOf("e");
-    if (exponentIndex < 0) {
-        return text;
-    }
-    const mantissa = text.slice(0, exponentIndex);
-    const exponent = Number(text.slice(exponentIndex + 1));
-    const sign = mantissa.startsWith("-") ? "-" : "";
-    const unsigned = sign ? mantissa.slice(1) : mantissa;
-    const decimalPoint = unsigned.indexOf(".");
-    const decimalIndex = (decimalPoint < 0 ? unsigned.length : decimalPoint) + exponent;
-    const digits = unsigned.replace(".", "");
-    if (decimalIndex <= 0) {
-        return `${sign}0.${"0".repeat(-decimalIndex)}${digits}`;
-    }
-    if (decimalIndex >= digits.length) {
-        return `${sign}${digits}${"0".repeat(decimalIndex - digits.length)}`;
-    }
-    return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;
-};
 export let turn_string = (x) => {
     if (x === null) {
         return "";
@@ -2053,75 +2039,75 @@ const typed_edn_error = (path, message) => {
 const enum_prototype_name = (value) => {
     return value instanceof CalcitEnumDef ? value.name() : value.name.value;
 };
-const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
+const decode_typed_edn_node = (graph, nodeId, input, path, depth, fail = typed_edn_error) => {
     if (depth > 1024)
-        typed_edn_error(path, "decode nesting exceeds 1024");
+        fail(path, "decode nesting exceeds 1024");
     const node = graph.nodes[nodeId];
     if (node == null)
-        typed_edn_error(path, `invalid data shape node #${nodeId}`);
+        fail(path, `invalid data shape node #${nodeId}`);
     switch (node.kind) {
         case "nil":
             if (input === null)
                 return null;
-            return typed_edn_error(path, `expected Nil, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected nil, got ${typed_edn_kind(input)}`);
         case "unit":
             if (input === undefined)
                 return input;
-            return typed_edn_error(path, `expected Unit, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected &unit, got ${typed_edn_kind(input)}`);
         case "bool":
             if (typeof input === "boolean")
                 return input;
-            return typed_edn_error(path, `expected bool, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected bool, got ${typed_edn_kind(input)}`);
         case "number":
             if (typeof input === "number")
                 return input;
-            return typed_edn_error(path, `expected number, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected number, got ${typed_edn_kind(input)}`);
         case "numeric":
             if (typeof input !== "number")
-                return typed_edn_error(path, `expected ${node.target}, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected ${node.target}, got ${typed_edn_kind(input)}`);
             if (_$n_number_$o_fits_$q_(input, newTag(node.target)))
                 return input;
-            return typed_edn_error(path, `number ${input} does not fit ${node.target}`);
+            return fail(path, `number ${input} does not fit ${node.target}`);
         case "string":
             if (typeof input === "string")
                 return input;
-            return typed_edn_error(path, `expected string, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected string, got ${typed_edn_kind(input)}`);
         case "symbol":
             if (input instanceof CalcitSymbol)
                 return input;
-            return typed_edn_error(path, `expected symbol, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected symbol, got ${typed_edn_kind(input)}`);
         case "tag":
             if (input instanceof CalcitTag)
                 return input;
-            return typed_edn_error(path, `expected tag, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected tag, got ${typed_edn_kind(input)}`);
         case "buffer":
             if (input instanceof Uint8Array)
                 return input;
-            return typed_edn_error(path, `expected buffer, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected buffer, got ${typed_edn_kind(input)}`);
         case "cirru-quote":
             if (input instanceof CalcitCirruQuote)
                 return input;
-            return typed_edn_error(path, `expected cirru-quote, got ${typed_edn_kind(input)}`);
+            return fail(path, `expected cirru-quote, got ${typed_edn_kind(input)}`);
         case "optional":
-            return input === null ? null : decode_typed_edn_node(graph, node.inner, input, path, depth + 1);
+            return input === null ? null : decode_typed_edn_node(graph, node.inner, input, path, depth + 1, fail);
         case "list": {
             if (!(input instanceof CalcitList || input instanceof CalcitSliceList)) {
-                return typed_edn_error(path, `expected list, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected list, got ${typed_edn_kind(input)}`);
             }
-            const values = Array.from(input.items()).map((value, idx) => decode_typed_edn_node(graph, node.inner, value, `${path}[${idx}]`, depth + 1));
+            const values = Array.from(input.items()).map((value, idx) => decode_typed_edn_node(graph, node.inner, value, `${path}[${idx}]`, depth + 1, fail));
             return new CalcitSliceList(values);
         }
         case "set": {
             if (!(input instanceof CalcitSet || input instanceof TypedEdnSetView)) {
-                return typed_edn_error(path, `expected set, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected set, got ${typed_edn_kind(input)}`);
             }
             const values = [];
             const inputValues = input instanceof TypedEdnSetView ? input.items : input.values();
             inputValues.forEach((value) => {
                 const itemPath = `${path}.item`;
-                const decoded = decode_typed_edn_node(graph, node.inner, value, itemPath, depth + 1);
+                const decoded = decode_typed_edn_node(graph, node.inner, value, itemPath, depth + 1, fail);
                 if (values.some((existing) => _$n__$e_(existing, decoded))) {
-                    typed_edn_error(itemPath, "duplicate decoded set value");
+                    fail(itemPath, "duplicate decoded set value");
                 }
                 values.push(decoded);
             });
@@ -2129,53 +2115,53 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
         }
         case "map": {
             if (!(input instanceof CalcitMap || input instanceof CalcitSliceMap)) {
-                return typed_edn_error(path, `expected map, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected map, got ${typed_edn_kind(input)}`);
             }
             const entries = [];
             input.pairs().forEach(([key, value]) => {
                 const keyPath = `${path}.key`;
-                const decodedKey = decode_typed_edn_node(graph, node.key, key, keyPath, depth + 1);
+                const decodedKey = decode_typed_edn_node(graph, node.key, key, keyPath, depth + 1, fail);
                 for (let idx = 0; idx < entries.length; idx += 2) {
                     if (_$n__$e_(entries[idx], decodedKey)) {
-                        typed_edn_error(keyPath, "duplicate decoded map key");
+                        fail(keyPath, "duplicate decoded map key");
                     }
                 }
-                const decodedValue = decode_typed_edn_node(graph, node.value, value, `${path}.value`, depth + 1);
+                const decodedValue = decode_typed_edn_node(graph, node.value, value, `${path}.value`, depth + 1, fail);
                 entries.push(decodedKey, decodedValue);
             });
             return new CalcitSliceMap(entries);
         }
         case "ref":
             if (!(input instanceof CalcitRef))
-                return typed_edn_error(path, `expected atom, got ${typed_edn_kind(input)}`);
-            return atom(decode_typed_edn_node(graph, node.inner, input.value, `${path}.value`, depth + 1));
+                return fail(path, `expected atom, got ${typed_edn_kind(input)}`);
+            return atom(decode_typed_edn_node(graph, node.inner, input.value, `${path}.value`, depth + 1, fail));
         case "struct": {
             if (!(input instanceof CalcitStructValue)) {
-                return typed_edn_error(path, `expected struct :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected struct :${node.nominal.name.value}, got ${typed_edn_kind(input)}`);
             }
             if (input.name.value !== node.nominal.name.value) {
-                return typed_edn_error(path, `expected struct :${node.nominal.name.value}, got struct :${input.name.value}`);
+                return fail(path, `expected struct :${node.nominal.name.value}, got struct :${input.name.value}`);
             }
             const expectedNames = node.fields.map(([name]) => name);
             const actualNames = input.fields.map((field) => field.value);
             const missing = expectedNames.filter((name) => !actualNames.includes(name)).sort();
             const unknown = actualNames.filter((name) => !expectedNames.includes(name)).sort();
             if (missing.length > 0 || unknown.length > 0 || expectedNames.length !== actualNames.length) {
-                return typed_edn_error(path, `struct :${node.nominal.name.value} fields mismatch; missing [${missing.join(", ")}], unknown [${unknown.join(", ")}]`);
+                return fail(path, `struct :${node.nominal.name.value} fields mismatch; missing [${missing.join(", ")}], unknown [${unknown.join(", ")}]`);
             }
             const decodedFields = new Map();
             node.fields.forEach(([name, fieldNode]) => {
                 const idx = actualNames.indexOf(name);
-                decodedFields.set(name, decode_typed_edn_node(graph, fieldNode, input.values[idx], `${path}.${name}`, depth + 1));
+                decodedFields.set(name, decode_typed_edn_node(graph, fieldNode, input.values[idx], `${path}.${name}`, depth + 1, fail));
             });
             // Re-align by name so values produced by older runtimes or external data
             // still adopt the current nominal declaration's canonical field layout.
             if (decodedFields.size !== node.nominal.fields.length) {
-                return typed_edn_error(path, `struct :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
+                return fail(path, `struct :${node.nominal.name.value} decoder fields do not match its nominal declaration`);
             }
             const values = node.nominal.fields.map((field) => {
                 if (!decodedFields.has(field.value)) {
-                    return typed_edn_error(path, `struct :${node.nominal.name.value} is missing declared field :${field.value}`);
+                    return fail(path, `struct :${node.nominal.name.value} is missing declared field :${field.value}`);
                 }
                 return decodedFields.get(field.value);
             });
@@ -2183,28 +2169,28 @@ const decode_typed_edn_node = (graph, nodeId, input, path, depth) => {
         }
         case "enum": {
             if (!(input instanceof CalcitEnumValue) || input.enumPrototype == null) {
-                return typed_edn_error(path, `expected enum :${node.nominal.name()}, got ${typed_edn_kind(input)}`);
+                return fail(path, `expected enum :${node.nominal.name()}, got ${typed_edn_kind(input)}`);
             }
             const actualEnumName = enum_prototype_name(input.enumPrototype);
             if (actualEnumName !== node.nominal.name()) {
-                return typed_edn_error(path, `expected enum :${node.nominal.name()}, got enum :${actualEnumName}`);
+                return fail(path, `expected enum :${node.nominal.name()}, got enum :${actualEnumName}`);
             }
             if (!(input.tag instanceof CalcitTag)) {
-                return typed_edn_error(path, `enum :${node.nominal.name()} variant must be a tag`);
+                return fail(path, `enum :${node.nominal.name()} variant must be a tag`);
             }
             const inputTag = input.tag;
             const variant = node.variants.find((candidate) => candidate.tag === inputTag.value);
             if (variant == null) {
-                return typed_edn_error(path, `enum :${node.nominal.name()} has no variant :${inputTag.value}`);
+                return fail(path, `enum :${node.nominal.name()} has no variant :${inputTag.value}`);
             }
             if (variant.payload.length !== input.extra.length) {
-                return typed_edn_error(path, `enum :${node.nominal.name()} variant :${variant.tag} expects ${variant.payload.length} payload(s), got ${input.extra.length}`);
+                return fail(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_typed_edn_node(graph, payloadNode, input.extra[idx], `${path}.payload[${idx}]`, depth + 1));
+            const values = variant.payload.map((payloadNode, idx) => decode_typed_edn_node(graph, payloadNode, input.extra[idx], `${path}.payload[${idx}]`, depth + 1, fail));
             return new CalcitEnumValue(newTag(variant.tag), values, node.nominal);
         }
         default:
-            return typed_edn_error(path, `invalid data shape node kind: ${node.kind}`);
+            return fail(path, `invalid data shape node kind: ${node.kind}`);
     }
 };
 export let parse_cirru_edn_as = (code, graph) => {
@@ -2355,7 +2341,7 @@ const decode_runtime_map_node = (graph, nodeId, input, path, depth) => {
             return new CalcitEnumValue(newTag(variant.tag), values, node.nominal);
         }
         default:
-            return decode_typed_edn_node(graph, nodeId, input, path, depth);
+            return decode_typed_edn_node(graph, nodeId, input, path, depth, map_decode_error);
     }
 };
 export let decode_map_as = (value, graph) => {
@@ -2980,23 +2966,30 @@ export let _$n_map_$o_diff_triple = (a, b) => {
         throw new Error("&map:diff-triple expected 2 maps");
     }
 };
+// Bitwise operands are integers within i32 (docs/data/number.md); JS would otherwise wrap or truncate them.
+let bit_operand = (name, x) => {
+    if (typeof x !== "number" || !Number.isInteger(x) || x < -2147483648 || x > 2147483647) {
+        throw new Error(`&math:${name} operand expected an integer within i32, but got: ${x}`);
+    }
+    return x;
+};
 export let bit_shr = (base, step) => {
-    return base >> step;
+    return bit_operand("bit-shr", base) >> bit_operand("bit-shr", step);
 };
 export let bit_shl = (base, step) => {
-    return base << step;
+    return bit_operand("bit-shl", base) << bit_operand("bit-shl", step);
 };
 export let bit_and = (a, b) => {
-    return a & b;
+    return bit_operand("bit-and", a) & bit_operand("bit-and", b);
 };
 export let bit_or = (a, b) => {
-    return a | b;
+    return bit_operand("bit-or", a) | bit_operand("bit-or", b);
 };
 export let bit_xor = (a, b) => {
-    return a ^ b;
+    return bit_operand("bit-xor", a) ^ bit_operand("bit-xor", b);
 };
 export let bit_not = (a) => {
-    return ~a;
+    return ~bit_operand("bit-not", a);
 };
 export let _$n_list_$o_to_set = (xs) => {
     var result = [];
@@ -3019,11 +3012,41 @@ export let _$n_list_$o_distinct = (xs) => {
     }
     return new CalcitSliceList(result);
 };
+// Longest padded string, the V8 string length limit, so every backend fails at the same size.
+const MAX_PADDED_LEN = 536870888;
+// Padding for `&str:pad-left` / `&str:pad-right`, measured in Unicode scalars like `&str:count`
+// (not UTF-16 units, so astral characters are never split). NaN and negative lengths pad nothing,
+// and so does an empty pattern.
+const strPadding = (procName, s, size, pattern) => {
+    if (size > MAX_PADDED_LEN) {
+        throw new Error(`${procName} expected a finite length up to ${MAX_PADDED_LEN}, but received: ${format_calcit_number(size)}`);
+    }
+    if (!(size > 0) || pattern === "")
+        return "";
+    let missing = Math.floor(size);
+    for (const _scalar of s) {
+        missing -= 1;
+        if (missing <= 0)
+            return "";
+    }
+    let patternCount = 0;
+    for (const _scalar of pattern)
+        patternCount += 1;
+    let padding = pattern.repeat(Math.floor(missing / patternCount));
+    let rest = missing % patternCount;
+    for (const scalar of pattern) {
+        if (rest <= 0)
+            break;
+        padding += scalar;
+        rest -= 1;
+    }
+    return padding;
+};
 export let _$n_str_$o_pad_left = (s, size, pattern) => {
-    return s.padStart(size, pattern);
+    return strPadding("&str:pad-left", s, size, pattern) + s;
 };
 export let _$n_str_$o_pad_right = (s, size, pattern) => {
-    return s.padEnd(size, pattern);
+    return s + strPadding("&str:pad-right", s, size, pattern);
 };
 export let _$n_get_os = () => {
     return newTag("js-engine");
@@ -3079,8 +3102,12 @@ export let macroexpand_all = unavailableProc;
 export let _$n_get_calcit_running_mode = unavailableProc;
 export let _$n_get_def_doc = unavailableProc;
 export let _$n_get_def_schema = unavailableProc;
-export let _$n_ffi_response_resolve = unavailableProc;
-export let _$n_ffi_response_reject = unavailableProc;
-export let _$n_ffi_task_cancel = unavailableProc;
+// A missing native lifecycle capability must not look like a successful Unit.
+const unavailableNativeFfi = (operation) => {
+    throw new Error(`${operation}: native FFI capability is not available for calcit-js`);
+};
+export let _$n_ffi_response_resolve = (..._args) => unavailableNativeFfi("&ffi-response-resolve");
+export let _$n_ffi_response_reject = (..._args) => unavailableNativeFfi("&ffi-response-reject");
+export let _$n_ffi_task_cancel = (..._args) => unavailableNativeFfi("&ffi-task-cancel");
 // already handled in code emitter
 export let raise = unavailableProc;

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@calcit/procs",
-    "version": "0.29.0-alpha.27",
+    "version": "0.29.0-alpha.29",
     "main": "./lib/calcit.procs.mjs",
     "files": [
         "lib/",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@calcit/procs",
-  "version": "0.29.0-alpha.27",
+  "version": "0.29.0-alpha.29",
   "main": "./lib/calcit.procs.mjs",
   "files": [
     "lib/",