@lotics/app-sdk 0.115.2 → 0.115.4

package/dist/index.js

@@ -716,19 +716,12 @@ function setKey(key, answer) {
 // src/written.ts
 import { useSyncExternalStore as useSyncExternalStore2 } from "react";
 
-// ../shared/src/add_operator.ts
-function addOrConcat(left, right, addNumbers) {
-  if (typeof left === "string" || typeof right === "string") {
-    return String(left ?? "") + String(right ?? "");
-  }
-  return addNumbers();
-}
-
 // ../shared/src/expression_limits.ts
 var MAX_RESULT_LENGTH = 1e5;
 var MAX_STRING_LENGTH = 1e7;
 var MAX_RANDOM_LENGTH = 1e3;
 var MAX_RUN_BUILT_BYTES = 512 * 1024 * 1024;
+var MAX_IN_PLACE_BYTES = 1024 * 1024;
 var MAX_PERSISTED_JSON_LENGTH = 64 * 1024 * 1024;
 var ExpressionLimitError = class extends Error {
   constructor(message2) {
@@ -808,21 +801,54 @@ function escapedLength(text2) {
 function isLowSurrogate(code) {
   return code >= 56320 && code <= 57343;
 }
+function textOf(value) {
+  if (!Array.isArray(value)) return ownText(value);
+  const parts = [];
+  walkJoined(value, (text2) => {
+    parts.push(text2);
+    return true;
+  });
+  return parts.join("");
+}
 function textLengthUpTo(value, max3) {
-  return textLength(value, max3, /* @__PURE__ */ new Set());
-}
-function textLength(value, max3, joining) {
-  if (!Array.isArray(value)) return String(value).length;
-  if (joining.has(value)) return 0;
-  joining.add(value);
-  let length2 = Math.max(0, value.length - 1);
-  for (let index = 0; index < value.length && length2 <= max3; index++) {
-    const element = value[index];
-    if (element != null) length2 += textLength(element, max3 - length2, joining);
-  }
-  joining.delete(value);
+  if (!Array.isArray(value)) return ownText(value).length;
+  let length2 = 0;
+  walkJoined(value, (text2) => {
+    length2 += text2.length;
+    return length2 <= max3;
+  });
   return length2;
 }
+function ownText(value) {
+  if (typeof value === "string") return value;
+  if (value instanceof Date) return Date.prototype.toString.call(value);
+  if (typeof value === "object" && value !== null) return Object.prototype.toString.call(value);
+  return String(value);
+}
+function walkJoined(array2, write2) {
+  const joining = /* @__PURE__ */ new Set([array2]);
+  const stack = [{ array: array2, at: 0 }];
+  while (stack.length > 0) {
+    const frame2 = stack[stack.length - 1];
+    if (frame2.at >= frame2.array.length) {
+      joining.delete(frame2.array);
+      stack.pop();
+      continue;
+    }
+    if (frame2.at > 0 && !write2(",")) return;
+    const element = frame2.array[frame2.at];
+    frame2.at += 1;
+    if (element === null || element === void 0) continue;
+    if (Array.isArray(element)) {
+      if (!joining.has(element)) {
+        joining.add(element);
+        stack.push({ array: element, at: 0 });
+      }
+      continue;
+    }
+    if (!write2(ownText(element))) return;
+  }
+}
 function jsonPreview(value, max3) {
   if (typeof value === "string") {
     const text2 = JSON.stringify(value.slice(0, max3));
@@ -832,6 +858,14 @@ function jsonPreview(value, max3) {
   return Array.isArray(value) ? `[\u2026 ${value.length} items]` : "{\u2026}";
 }
 
+// ../shared/src/add_operator.ts
+function addOrConcat(left, right, addNumbers) {
+  if (typeof left === "string" || typeof right === "string") {
+    return textOf(left ?? "") + textOf(right ?? "");
+  }
+  return addNumbers();
+}
+
 // ../../node_modules/jexpr/lib/constants.js
 var KEYWORDS = ["this"];
 var UNARY_OPERATORS = ["+", "-", "!"];
@@ -1691,6 +1725,16 @@ __export(expression_array_exports, {
   unique: () => unique,
   uniqueBy: () => uniqueBy
 });
+
+// ../shared/src/own_property.ts
+function ownMember(value, key) {
+  return Object.hasOwn(value, key) ? Reflect.get(value, key) : void 0;
+}
+function defineOwn(target, key, value) {
+  Object.defineProperty(target, key, { value, writable: true, enumerable: true, configurable: true });
+}
+
+// ../shared/src/expression_array.ts
 function getField(obj, field) {
   if (obj == null) return void 0;
   const parts = field.split(".");
@@ -1698,10 +1742,17 @@ function getField(obj, field) {
   for (const part of parts) {
     if (value == null) return void 0;
     if (typeof value !== "object") return void 0;
-    value = value[part];
+    value = ownMember(value, part);
   }
   return value;
 }
+function countInto(result, key) {
+  defineOwn(result, key, (Object.hasOwn(result, key) ? result[key] : 0) + 1);
+}
+function groupInto(result, key, item) {
+  if (Object.hasOwn(result, key)) result[key].push(item);
+  else defineOwn(result, key, [item]);
+}
 function compareValues(a, b) {
   if (a == null && b == null) return 0;
   if (a == null) return 1;
@@ -1863,7 +1914,7 @@ function countBy(arr, fieldOrCb) {
       const result2 = {};
       for (const val of keys2) {
         const key = val == null ? "null" : String(val);
-        result2[key] = (result2[key] || 0) + 1;
+        countInto(result2, key);
       }
       return result2;
     });
@@ -1876,7 +1927,7 @@ function countBy(arr, fieldOrCb) {
   for (const item of arr) {
     const val = getField(item, field);
     const key = val == null ? "null" : String(val);
-    result[key] = (result[key] || 0) + 1;
+    countInto(result, key);
   }
   return result;
 }
@@ -1996,7 +2047,7 @@ function groupBy(arr, fieldOrCb) {
       const result2 = {};
       for (let i = 0; i < arr.length; i++) {
         const key = keys2[i] == null ? "null" : String(keys2[i]);
-        (result2[key] ??= []).push(arr[i]);
+        groupInto(result2, key, arr[i]);
       }
       return result2;
     });
@@ -2009,10 +2060,7 @@ function groupBy(arr, fieldOrCb) {
   for (const item of arr) {
     const val = getField(item, field);
     const key = val == null ? "null" : String(val);
-    if (!result[key]) {
-      result[key] = [];
-    }
-    result[key].push(item);
+    groupInto(result, key, item);
   }
   return result;
 }
@@ -2946,7 +2994,7 @@ function getNestedValue(obj, path) {
   for (const part of parts) {
     if (value == null) return void 0;
     if (typeof value !== "object") return void 0;
-    value = value[part];
+    value = ownMember(value, part);
   }
   return value;
 }
@@ -3002,9 +3050,7 @@ function pick(obj, fields) {
   const objRecord = obj;
   for (const field of fields) {
     const fieldStr = String(field);
-    if (fieldStr in objRecord) {
-      result[fieldStr] = objRecord[fieldStr];
-    }
+    if (Object.hasOwn(objRecord, fieldStr)) defineOwn(result, fieldStr, objRecord[fieldStr]);
   }
   return result;
 }
@@ -3022,10 +3068,8 @@ function omit(obj, fields) {
   const result = {};
   const objRecord = obj;
   const fieldsSet = new Set(fields.map(String));
-  for (const key in objRecord) {
-    if (!fieldsSet.has(key)) {
-      result[key] = objRecord[key];
-    }
+  for (const key of Object.keys(objRecord)) {
+    if (!fieldsSet.has(key)) defineOwn(result, key, objRecord[key]);
   }
   return result;
 }
@@ -3153,7 +3197,7 @@ function toString(val) {
   if (typeof val !== "string" && textLengthUpTo(val, MAX_STRING_LENGTH) > MAX_STRING_LENGTH) {
     throw new ExpressionLimitError(`toString: result too long (max ${MAX_STRING_LENGTH} characters)`);
   }
-  return String(val);
+  return textOf(val);
 }
 function isNull(val) {
   return val === null || val === void 0;
@@ -27341,6 +27385,12 @@ var WorkflowExpressionBudgetError = class extends Error {
   }
   budget;
 };
+var ExpressionNotCheapError = class extends Error {
+  constructor() {
+    super(`The expression walks or builds more than ${MAX_IN_PLACE_BYTES / 1024 / 1024}MB at once, past what an evaluation in place may.`);
+    this.name = "ExpressionNotCheapError";
+  }
+};
 function budgetMessage(budget) {
   switch (budget.exceeded) {
     case "bytes":
@@ -27388,6 +27438,66 @@ function builtSize(value) {
   if (typeof value === "object" && value !== null) return OBJECT_BYTES + Object.keys(value).length * SLOT_BYTES;
   return 0;
 }
+var LONGEST_NUMBER_TEXT = 24;
+function numberTextLength(value) {
+  if (!Number.isSafeInteger(value)) return LONGEST_NUMBER_TEXT;
+  let length2 = value < 0 ? 2 : 1;
+  for (let rest = Math.abs(value); rest >= 10; rest = Math.floor(rest / 10)) length2 += 1;
+  return length2;
+}
+function expandedSize(value, max3) {
+  let bytes = 0;
+  const pending = [value];
+  while (pending.length > 0 && bytes <= max3) {
+    const member = pending.pop();
+    if (typeof member === "string") bytes += member.length * CHAR_BYTES;
+    else if (typeof member === "number") bytes += numberTextLength(member) * CHAR_BYTES;
+    else if (typeof member === "boolean") bytes += (member ? 4 : 5) * CHAR_BYTES;
+    else if (typeof member === "bigint") bytes += String(member).length * CHAR_BYTES;
+    else if (typeof member !== "object" || member === null) continue;
+    else if (member instanceof Map) {
+      bytes += OBJECT_BYTES + member.size * 2 * SLOT_BYTES;
+      if (bytes <= max3) for (const [key, held2] of member) pending.push(key, held2);
+    } else if (member instanceof Set) {
+      bytes += OBJECT_BYTES + member.size * SLOT_BYTES;
+      if (bytes <= max3) for (const held2 of member) pending.push(held2);
+    } else if (Array.isArray(member)) {
+      bytes += OBJECT_BYTES + member.length * SLOT_BYTES;
+      if (bytes <= max3) for (let at2 = 0; at2 < member.length; at2++) pending.push(member[at2]);
+    } else {
+      const known = ownKeyBytes.get(member);
+      if (known !== void 0 && bytes + known > max3) {
+        bytes += known;
+        continue;
+      }
+      const keys2 = Object.keys(member);
+      let own = OBJECT_BYTES + keys2.length * SLOT_BYTES;
+      for (const key of keys2) own += key.length * CHAR_BYTES;
+      ownKeyBytes.set(member, own);
+      bytes += own;
+      if (bytes <= max3) for (const key of keys2) pending.push(Reflect.get(member, key));
+    }
+  }
+  return bytes;
+}
+var ownKeyBytes = /* @__PURE__ */ new WeakMap();
+var OBJECT_TEXT_LENGTH = 64;
+function writtenSize(value, max3) {
+  let bytes = 0;
+  const pending = [value];
+  while (pending.length > 0 && bytes <= max3) {
+    const member = pending.pop();
+    if (typeof member === "string") bytes += member.length * CHAR_BYTES;
+    else if (typeof member === "number") bytes += numberTextLength(member) * CHAR_BYTES;
+    else if (typeof member === "boolean") bytes += (member ? 4 : 5) * CHAR_BYTES;
+    else if (typeof member === "bigint") bytes += String(member).length * CHAR_BYTES;
+    else if (Array.isArray(member)) {
+      bytes += OBJECT_BYTES + member.length * SLOT_BYTES;
+      if (bytes <= max3) for (let at2 = 0; at2 < member.length; at2++) pending.push(member[at2]);
+    } else if (typeof member === "object" && member !== null) bytes += OBJECT_TEXT_LENGTH * CHAR_BYTES;
+  }
+  return bytes;
+}
 var PARSED_NODE_BYTES = 40;
 var OPEN_BRACKET = "[".charCodeAt(0);
 var OPEN_BRACE = "{".charCodeAt(0);
@@ -27401,6 +27511,22 @@ function parsedSize(text2) {
   }
   return text2.length * CHAR_BYTES + nodes * PARSED_NODE_BYTES;
 }
+function assertCheap(budget, ...values2) {
+  if (!budget.bounded) return;
+  let bytes = 0;
+  for (const value of values2) {
+    bytes += writtenSize(value, MAX_IN_PLACE_BYTES - bytes);
+    if (bytes > MAX_IN_PLACE_BYTES) throw new ExpressionNotCheapError();
+  }
+}
+function charge(ctx, bytes) {
+  const budget = ctx.evaluation_budget;
+  assertUnsettled(budget);
+  if (Date.now() > ctx.run_budget.deadline_ms) throw new WorkflowTimeBudgetError(ctx.run_budget.subject, ctx.run_budget.budget_ms);
+  if (budget.bounded && budget.built + bytes > MAX_IN_PLACE_BYTES) throw new ExpressionNotCheapError();
+  budget.built += bytes;
+  chargeBuilt(ctx.run_budget, bytes);
+}
 function callbackWorkers() {
   let free = LINK_FETCH_CONCURRENCY - 1;
   return {
@@ -27414,10 +27540,16 @@ function callbackWorkers() {
     }
   };
 }
-function evaluateWorkflowExpression(expr2, ctx) {
-  const budget = { workers: callbackWorkers(), settled: false };
+function evaluateWorkflowExpression(expr2, ctx, options = {}) {
+  const budget = { workers: callbackWorkers(), bounded: options.bounded === true, built: 0, settled: false };
   return evaluateExpression(expr2, { ...ctx, evaluation_budget: budget }).finally(() => {
     budget.settled = true;
+  }).then((answer) => {
+    if (budget.bounded && expandedSize(answer, MAX_IN_PLACE_BYTES) > MAX_IN_PLACE_BYTES) throw new ExpressionNotCheapError();
+    return answer;
+  }).catch((error51) => {
+    if (budget.bounded && ctx.run_budget.host === "shared") ctx.run_budget.built_bytes -= budget.built;
+    throw error51;
   });
 }
 async function evaluateExpression(expr2, ctx) {
@@ -27443,15 +27575,13 @@ async function evaluateExpression(expr2, ctx) {
       return evaluateLambda(expr2.params, expr2.body, ctx, []);
     case "array_literal": {
       const elements = await Promise.all(expr2.elements.map((el) => evaluateExpression(el, ctx)));
-      chargeBuilt(ctx.run_budget, builtSize(elements));
+      charge(ctx, builtSize(elements));
       return elements;
     }
     case "object_literal": {
       const out = {};
-      for (const entry of expr2.entries) {
-        out[entry.key] = await evaluateExpression(entry.value, ctx);
-      }
-      chargeBuilt(ctx.run_budget, builtSize(out));
+      for (const entry of expr2.entries) defineOwn(out, entry.key, await evaluateExpression(entry.value, ctx));
+      charge(ctx, builtSize(out));
       return out;
     }
     default:
@@ -27472,9 +27602,7 @@ function assertUnsettled(budget) {
 function evaluateLambda(params, body, ctx, items) {
   const call = async (...args) => {
     const frame2 = {};
-    for (let i = 0; i < params.length; i++) {
-      frame2[params[i]] = args[i];
-    }
+    for (let i = 0; i < params.length; i++) defineOwn(frame2, params[i], args[i]);
     const stack = ctx.lambda_params ?? [];
     const newStack = [...stack, frame2];
     const innerCtx = {
@@ -27542,16 +27670,14 @@ function resolveReadRoot(source, ctx) {
     case "foreach_index":
       return resolveForeachFrame(ctx, void 0, "foreach_index").index;
     case "step_output": {
-      if (!(source.step_id in ctx.step_outputs)) {
+      if (!Object.hasOwn(ctx.step_outputs, source.step_id)) {
         throw new WorkflowEvalError(
           `Read from step_output "${source.step_id}", but no such step has run`,
           { kind: "read", at: "step_output", extra: { step_id: source.step_id } }
         );
       }
       const stored = ctx.step_outputs[source.step_id];
-      if (stored && typeof stored === "object" && "output" in stored) {
-        return stored.output;
-      }
+      if (stored && typeof stored === "object" && Object.hasOwn(stored, "output")) return ownMember(stored, "output");
       return stored;
     }
     case "runtime":
@@ -27561,7 +27687,7 @@ function resolveReadRoot(source, ctx) {
       if (stack !== void 0) {
         for (let i = stack.length - 1; i >= 0; i--) {
           const frame2 = stack[i];
-          if (source.name in frame2) return frame2[source.name];
+          if (Object.hasOwn(frame2, source.name)) return frame2[source.name];
         }
       }
       throw new WorkflowEvalError(
@@ -27574,7 +27700,7 @@ function resolveReadRoot(source, ctx) {
       if (stack !== void 0) {
         for (let i = stack.length - 1; i >= 0; i--) {
           const frame2 = stack[i];
-          if (source.name in frame2) return frame2[source.name];
+          if (Object.hasOwn(frame2, source.name)) return frame2[source.name];
         }
       }
       throw new WorkflowEvalError(
@@ -27676,63 +27802,74 @@ async function coerceFieldDisplay(value, field, ctx) {
   if (value === null || value === void 0) return value;
   switch (field.type) {
     case "select":
-      return coerceSelectDisplay(value, field.options);
+      return coerceSelectDisplay(value, field.options, ctx);
     // One of its own options, named as a select's is.
     case "formula":
-      return field.formula.options === void 0 ? value : coerceSelectDisplay(value, field.formula.options);
+      return field.formula.options === void 0 ? value : coerceSelectDisplay(value, field.formula.options, ctx);
     case "select_record_link":
       return coerceRecordLinkDisplay(value, field, ctx);
     case "select_member":
       return coerceMemberDisplay(value, ctx);
     case "lookup":
-      return field.lookup_field_options ? coerceOptionKeysDeep(value, field.lookup_field_options) : value;
+      return field.lookup_field_options ? coerceOptionKeysDeep(value, field.lookup_field_options, ctx) : value;
     default:
       return value;
   }
 }
-function coerceSelectDisplay(value, options) {
+function coerceSelectDisplay(value, options, ctx) {
   const optionMap = new Map(options.map((o) => [o.key, o.name]));
   const resolve = (key) => {
     if (typeof key !== "string") return "";
     return optionMap.get(key) ?? key;
   };
-  if (Array.isArray(value)) return value.map(resolve);
-  return resolve(value);
+  if (!Array.isArray(value)) return resolve(value);
+  assertCheap(ctx.evaluation_budget, value);
+  const names = value.map(resolve);
+  charge(ctx, builtSize(names));
+  return names;
 }
-function coerceOptionKeysDeep(value, options) {
+function coerceOptionKeysDeep(value, options, ctx) {
+  assertCheap(ctx.evaluation_budget, value);
   const optionMap = new Map(options.map((o) => [o.key, o.name]));
   const resolve = (v) => {
-    if (Array.isArray(v)) return v.map(resolve);
+    if (Array.isArray(v)) {
+      const resolved = v.map(resolve);
+      charge(ctx, builtSize(resolved));
+      return resolved;
+    }
     if (typeof v === "string") return optionMap.get(v) ?? v;
     return v;
   };
   return resolve(value);
 }
 async function coerceMemberDisplay(value, ctx) {
+  if (Array.isArray(value)) assertCheap(ctx.evaluation_budget, value);
   const ids = Array.isArray(value) ? value.filter((v) => typeof v === "string") : typeof value === "string" ? [value] : [];
   if (ids.length === 0) return Array.isArray(value) ? [] : "";
   const nameMap = await ctx.member_lookup(ids);
   const names = new Set(nameMap.values());
   const resolve = (id) => nameMap.get(id) ?? (names.has(id) ? id : "");
-  return Array.isArray(value) ? value.map((v) => resolve(String(v))) : resolve(ids[0]);
+  if (!Array.isArray(value)) return resolve(ids[0]);
+  const shown = value.map((v) => resolve(textOf(v)));
+  charge(ctx, builtSize(shown));
+  return shown;
 }
 async function coerceRecordLinkDisplay(value, field, ctx) {
   if (!Array.isArray(value)) return value;
+  assertCheap(ctx.evaluation_budget, value);
   const displayFieldKeys = field.display_field_keys ?? [];
-  return Promise.all(
-    value.map(async (id) => {
-      if (typeof id !== "string") return "";
-      const data = await fetchRecordData(id, ctx);
-      if (!data) return "";
-      if (displayFieldKeys.length === 0) {
-        return "";
-      }
-      return displayFieldKeys.map((key) => {
-        const v = data[key];
-        return v === null || v === void 0 ? "" : String(v);
-      }).filter((s) => s !== "").join(" ");
-    })
+  const rows = await fetchRecordsBounded(
+    value.map((id) => typeof id === "string" ? id : null),
+    `Showing "${field.key}"`,
+    ctx
   );
+  const shown = rows.map((row2) => row2 === null ? [] : displayFieldKeys.map((key) => row2[key]));
+  assertCheap(ctx.evaluation_budget, shown);
+  const texts = shown.map(
+    (values2) => values2.filter((v) => v !== null && v !== void 0).map(textOf).filter((text2) => text2 !== "").join(" ")
+  );
+  charge(ctx, texts.reduce((bytes, text2) => bytes + builtSize(text2), builtSize(texts)));
+  return texts;
 }
 function advanceTable(segment, currentTable, ctx) {
   if (segment.at === "linked" && currentTable) {
@@ -27762,7 +27899,7 @@ async function walkSegment(value, segment, ctx) {
         return void 0;
       }
       if (typeof value !== "object") return void 0;
-      return value[segment.key];
+      return ownMember(value, segment.key);
     }
     case "index": {
       if (value === null || value === void 0) return void 0;
@@ -27772,7 +27909,7 @@ async function walkSegment(value, segment, ctx) {
       }
       if (typeof value === "object") {
         const key = typeof segment.index === "number" ? String(segment.index) : await resolveObjectKeyExpression(segment.index, ctx);
-        return value[key];
+        return ownMember(value, key);
       }
       throw new WorkflowEvalError(
         `Cannot index ${typeof value} \u2014 only an array or an object can be read by index.`,
@@ -27790,9 +27927,8 @@ async function resolveObjectKeyExpression(expr2, ctx) {
   throw new WorkflowEvalError(
     // Bounded: the value is whatever the expression produced — a whole record,
     // a page of rows — and the message goes into a persisted execution row and
-    // an author-facing error. The type is what names the fault; a prefix is
-    // enough to recognize which value it was.
-    `Computed object key must evaluate to a string, got ${value === null ? "null" : typeof value}: ${jsonPreview(value, VALUE_PREVIEW_LENGTH)}`,
+    // an author-facing error.
+    `Computed object key must evaluate to a string, got ${describeValue(value)}`,
     { kind: "read", at: "index" }
   );
 }
@@ -27801,7 +27937,7 @@ async function resolveIndexExpression(expr2, ctx, context) {
   const value = await evaluateExpression(expr2, ctx);
   if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
     throw new WorkflowEvalError(
-      `Computed ${context} must evaluate to a non-negative integer, got ${value === null ? "null" : typeof value}: ${jsonPreview(value, VALUE_PREVIEW_LENGTH)}`,
+      `Computed ${context} must evaluate to a non-negative integer, got ${describeValue(value)}`,
       { kind: "read", at: "index" }
     );
   }
@@ -27815,17 +27951,17 @@ async function walkLinked(value, segment, ctx) {
       { kind: "read", at: "linked", extra: { via: segment.via } }
     );
   }
-  const linkValue = value[segment.via];
-  const ids = extractLinkIds(linkValue, segment.via);
+  const ids = linkIds(ownMember(value, segment.via), segment.via);
   if (segment.index === "each") {
-    return fetchRecordsBounded(ids, segment.via, ctx);
+    assertCheap(ctx.evaluation_budget, ids);
+    return fetchRecordsBounded(ids.map((id) => assertLinkId(id, segment.via)), `linked(...) on "${segment.via}"`, ctx);
   }
   const idx = typeof segment.index === "number" ? segment.index : await resolveIndexExpression(segment.index, ctx, `linked index via "${segment.via}"`);
   const target = ids[idx];
   if (target === void 0) return void 0;
-  return fetchRecordData(target, ctx);
+  return fetchRecordData(assertLinkId(target, segment.via), ctx);
 }
-function extractLinkIds(value, via) {
+function linkIds(value, via) {
   if (value === void 0 || value === null) return [];
   if (!Array.isArray(value)) {
     throw new WorkflowEvalError(
@@ -27833,16 +27969,17 @@ function extractLinkIds(value, via) {
       { kind: "read", at: "linked", extra: { via } }
     );
   }
-  for (const item of value) {
-    if (typeof item !== "string") {
-      throw new WorkflowEvalError(
-        `Linked field "${via}" contains a non-string item \u2014 record data must be normalized before evaluation`,
-        { kind: "read", at: "linked", extra: { via, item_type: typeof item } }
-      );
-    }
-  }
   return value;
 }
+function assertLinkId(item, via) {
+  if (typeof item !== "string") {
+    throw new WorkflowEvalError(
+      `Linked field "${via}" contains a non-string item \u2014 record data must be normalized before evaluation`,
+      { kind: "read", at: "linked", extra: { via, item_type: typeof item } }
+    );
+  }
+  return item;
+}
 async function fetchRecordData(recordId, ctx) {
   if (ctx.record_cache.has(recordId)) {
     return ctx.record_cache.get(recordId) ?? null;
@@ -27854,18 +27991,18 @@ async function fetchRecordData(recordId, ctx) {
 }
 var LINK_FETCH_CONCURRENCY = 20;
 var MAX_LINK_FAN_OUT = 1e4;
-async function fetchRecordsBounded(ids, via, ctx) {
+async function fetchRecordsBounded(ids, reading, ctx) {
   if (ids.length > MAX_LINK_FAN_OUT) {
     throw new WorkflowEvalError(
-      `linked(...) on "${via}" would fetch ${ids.length} rows, over the cap of ${MAX_LINK_FAN_OUT}. Index one row \u2014 linked(...)[i] \u2014 or narrow the link.`,
-      { kind: "read", at: "linked", extra: { via } }
+      `${reading} would fetch ${ids.length} rows, over the cap of ${MAX_LINK_FAN_OUT}. Index one row \u2014 linked(...)[i] \u2014 or narrow the link.`,
+      { kind: "read", at: "linked", extra: { reading } }
     );
   }
   const results = [];
   for (let i = 0; i < ids.length; i += LINK_FETCH_CONCURRENCY) {
     for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
     const chunk = ids.slice(i, i + LINK_FETCH_CONCURRENCY);
-    results.push(...await Promise.all(chunk.map((id) => fetchRecordData(id, ctx))));
+    results.push(...await Promise.all(chunk.map((id) => id === null ? null : fetchRecordData(id, ctx))));
   }
   return results;
 }
@@ -27885,12 +28022,12 @@ async function evaluateCall(fn, args, ctx) {
   );
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
   const cost = helperCost(fn);
-  if (cost === "parses") chargeBuilt(ctx.run_budget, parsedSize(evaluatedArgs[0]));
+  if (cost === "parses") charge(ctx, parsedSize(evaluatedArgs[0]));
   const answer = await helper(...evaluatedArgs);
   if (cost !== "builds" && cost !== "nested") return answer;
   const handedBack = evaluatedArgs.indexOf(answer);
   if (handedBack !== -1) return evaluatedArgs[handedBack];
-  chargeBuilt(ctx.run_budget, builtSize(answer) + (cost === "nested" ? builtSize(evaluatedArgs[0]) : 0));
+  charge(ctx, builtSize(answer) + (cost === "nested" ? builtSize(evaluatedArgs[0]) : 0));
   return answer;
 }
 async function evaluateBinary(op, leftExpr, rightExpr, ctx) {
@@ -27911,9 +28048,9 @@ async function evaluateBinary(op, leftExpr, rightExpr, ctx) {
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
   switch (op) {
     case "eq":
-      return looseEq(left, right);
     case "neq":
-      return !looseEq(left, right);
+      assertCheap(ctx.evaluation_budget, looselyComparedText(left, right));
+      return looseEq(left, right) === (op === "eq");
     case "seq":
       return strictEq(left, right);
     case "sneq":
@@ -27928,10 +28065,11 @@ async function evaluateBinary(op, leftExpr, rightExpr, ctx) {
       return compareOrdered(left, right) <= 0;
     case "add": {
       if (typeof left === "string" || typeof right === "string") {
+        assertCheap(ctx.evaluation_budget, left, right);
         assertTextWithin("+", typeof left === "string" ? null : left, typeof right === "string" ? null : right);
       }
       const sum2 = addOrConcat(left, right, () => assertNumber(left, "add", "left") + assertNumber(right, "add", "right"));
-      chargeBuilt(ctx.run_budget, builtSize(sum2));
+      charge(ctx, builtSize(sum2));
       return sum2;
     }
     case "sub":
@@ -27955,8 +28093,21 @@ async function evaluateBinary(op, leftExpr, rightExpr, ctx) {
   }
 }
 function looseEq(a, b) {
+  if (isComposite(a) && b !== null && b !== void 0 && !isComposite(b)) return looseEq(textOf(a), b);
+  if (isComposite(b) && a !== null && a !== void 0 && !isComposite(a)) return looseEq(a, textOf(b));
   return a == b;
 }
+function isComposite(value) {
+  return typeof value === "object" && value !== null;
+}
+function looselyComparedText(a, b) {
+  if (Array.isArray(a) && isScalar(b)) return a;
+  if (Array.isArray(b) && isScalar(a)) return b;
+  return null;
+}
+function isScalar(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" || typeof value === "bigint";
+}
 function strictEq(a, b) {
   return a === b;
 }
@@ -27990,8 +28141,14 @@ function describeValue(value) {
   if (typeof value === "string") return `string ${jsonPreview(value, VALUE_PREVIEW_LENGTH)}`;
   if (typeof value === "number") return `number ${String(value)}`;
   if (typeof value === "boolean") return `boolean ${String(value)}`;
-  const kind = Array.isArray(value) ? "array" : typeof value;
-  return textLengthUpTo(value, VALUE_PREVIEW_LENGTH) <= VALUE_PREVIEW_LENGTH ? `${kind} ${String(value)}` : kind;
+  if (!Array.isArray(value)) return typeof value;
+  let length2 = 0;
+  for (let at2 = 0; at2 < value.length && length2 <= VALUE_PREVIEW_LENGTH; at2++) {
+    const element = value[at2];
+    if (element !== null && element !== void 0 && !isScalar(element)) return "array";
+    length2 += (typeof element === "string" ? element.length : LONGEST_NUMBER_TEXT) + 1;
+  }
+  return value.length > 0 && length2 <= VALUE_PREVIEW_LENGTH ? `array ${value.join(",")}` : "array";
 }
 async function evaluateUnary(op, argExpr, ctx) {
   const value = await evaluateExpression(argExpr, ctx);
@@ -28013,9 +28170,10 @@ async function evaluateTemplate(parts, ctx) {
     parts.map((part) => part.t === "text" ? part.s : evaluateExpression(part.e, ctx))
   );
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
+  assertCheap(ctx.evaluation_budget, ...evaluated2);
   assertTextWithin("template", ...evaluated2);
   const text2 = evaluated2.map(stringifyForTemplate).join("");
-  chargeBuilt(ctx.run_budget, builtSize(text2));
+  charge(ctx, builtSize(text2));
   return text2;
 }
 function assertTextWithin(writer, ...values2) {
@@ -28029,8 +28187,7 @@ function assertTextWithin(writer, ...values2) {
 }
 function stringifyForTemplate(value) {
   if (value === null || value === void 0) return "";
-  if (typeof value === "string") return value;
-  return String(value);
+  return textOf(value);
 }
 
 // ../shared/src/id.ts
@@ -28090,6 +28247,11 @@ function knownCells(tables, tableId, cells) {
       },
       has(target, key) {
         return isField(key) || Reflect.has(target, key);
+      },
+      // An expression reads only what a row holds itself (`ownMember`).
+      getOwnPropertyDescriptor(target, key) {
+        if (isField(key) && !Object.hasOwn(target, key)) unread(key);
+        return Reflect.getOwnPropertyDescriptor(target, key);
       }
     }
   );
@@ -28099,6 +28261,11 @@ function modelled(stepId, output) {
     get(target, key) {
       if (typeof key === "string" && key !== "then" && !(key in target)) unread(`${stepId}.${key}`);
       return Reflect.get(target, key);
+    },
+    // An expression reads only what an output holds itself (`ownMember`).
+    getOwnPropertyDescriptor(target, key) {
+      if (typeof key === "string" && key !== "then" && !Object.hasOwn(target, key)) unread(`${stepId}.${key}`);
+      return Reflect.getOwnPropertyDescriptor(target, key);
     }
   });
 }
@@ -31353,33 +31520,37 @@ function buildDependencyGraph(formulaFields, allFields) {
   }
   return { sortedFields: result, circularDependencies };
 }
-function readsFieldsOnlyThroughEmptinessPredicates(node) {
+function readsFieldsOnlyThroughEmptinessPredicates(node, taken) {
+  const reads = (child) => readsFieldsOnlyThroughEmptinessPredicates(child, taken);
   if (node === void 0) return true;
   if (isFieldRead(node)) return false;
   switch (node.type) {
     case "Invoke": {
       const args = node.arguments ?? [];
       const predicate = node.method === void 0 && node.receiver.type === "ID" && EMPTINESS_PREDICATES.has(node.receiver.value);
-      return (predicate || readsFieldsOnlyThroughEmptinessPredicates(node.receiver)) && args.every(
-        (arg) => predicate && isFieldRead(arg) || readsFieldsOnlyThroughEmptinessPredicates(arg)
+      return (predicate || reads(node.receiver)) && args.every(
+        (arg) => predicate && isFieldRead(arg) || reads(arg)
       );
     }
     case "Unary":
-      return readsFieldsOnlyThroughEmptinessPredicates(node.child);
+      return reads(node.child);
     case "Binary":
-      return readsFieldsOnlyThroughEmptinessPredicates(node.left) && readsFieldsOnlyThroughEmptinessPredicates(node.right);
+      return reads(node.left) && reads(node.right);
     case "Getter":
-      return readsFieldsOnlyThroughEmptinessPredicates(node.receiver);
+      return reads(node.receiver);
     case "Index":
-      return readsFieldsOnlyThroughEmptinessPredicates(node.receiver) && readsFieldsOnlyThroughEmptinessPredicates(node.argument);
-    case "Ternary":
-      return readsFieldsOnlyThroughEmptinessPredicates(node.condition) && readsFieldsOnlyThroughEmptinessPredicates(node.trueExpr) && readsFieldsOnlyThroughEmptinessPredicates(node.falseExpr);
+      return reads(node.receiver) && reads(node.argument);
+    case "Ternary": {
+      if (!reads(node.condition)) return false;
+      const decided = node.condition === void 0 || taken === void 0 ? void 0 : taken(node.condition);
+      return decided === true ? reads(node.trueExpr) : decided === false ? reads(node.falseExpr) : reads(node.trueExpr) && reads(node.falseExpr);
+    }
     case "List":
-      return (node.items ?? []).every(readsFieldsOnlyThroughEmptinessPredicates);
+      return (node.items ?? []).every((item) => reads(item));
     case "Map":
-      return Object.values(node.entries ?? {}).every(readsFieldsOnlyThroughEmptinessPredicates);
+      return Object.values(node.entries ?? {}).every((entry) => reads(entry));
     case "ArrowFunction":
-      return readsFieldsOnlyThroughEmptinessPredicates(node.body);
+      return reads(node.body);
     case "ID":
       return node.value !== "data";
     case "Literal":
@@ -31392,8 +31563,13 @@ function isFieldRead(node) {
 }
 function evaluateFormulaWithJS(preparedExpression, data, timezone, everyReferenceEmpty) {
   try {
-    if (everyReferenceEmpty && !readsFieldsOnlyThroughEmptinessPredicates(parseExpression(preparedExpression))) {
-      return null;
+    if (everyReferenceEmpty) {
+      const helpers = createTimezoneAwareFunctions(timezone);
+      const taken = (condition2) => {
+        const answer = condition2.evaluate({ ...data, ...helpers });
+        return typeof answer === "boolean" ? answer : void 0;
+      };
+      if (!readsFieldsOnlyThroughEmptinessPredicates(parseExpression(preparedExpression), taken)) return null;
     }
     const result = evaluateJsExpression(preparedExpression, data, void 0, timezone);
     if (result === null || result === void 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.115.2",
+  "version": "0.115.4",
   "description": "The SDK a Lotics custom-code app reads and writes through \u2014 typed hooks over the host bridge, cell readers, mount() and AppRouter",
   "type": "module",
   "exports": {