@lotics/app-sdk 0.115.1 → 0.115.3

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;
@@ -21918,20 +21962,31 @@ function sameReading(a, b) {
 function readingWords(reading) {
   return reading === "link" ? "a link" : JSON.stringify(reading);
 }
-function settledReading(written, stored) {
-  const held2 = stored === void 0 ? void 0 : stored.byKeys ?? stored.stated;
-  const { stated, byKeys } = written;
-  const parted = partedReadings(written);
-  if (parted === void 0) return checkedReading(stated ?? byKeys ?? held2, held2);
-  const changed2 = stored === void 0 ? void 0 : sameReading(stated, stored.stated) ? byKeys : sameReading(byKeys, stored.byKeys) ? stated : void 0;
-  return changed2 === void 0 ? { refusal: parted } : checkedReading(changed2, held2);
-}
-function partedReadings(written) {
-  const { stated, byKeys } = written;
-  if (stated === void 0 || byKeys === void 0 || sameReading(stated, byKeys)) return void 0;
-  const key = stated === "link" ? "link" : "notation";
+function heldReading(stored) {
+  return stored.byKeys ?? stored.stated;
+}
+function leftReading(written, stored) {
+  if (stored === void 0) return { changed: written.stated, left: written.stated };
+  const changed2 = sameReading(written.stated, stored.stated) ? void 0 : written.stated;
+  return { changed: changed2, left: changed2 ?? heldReading(stored) ?? written.stated };
+}
+function keysRefusal(written, stored) {
+  const { byKeys } = written;
+  if (byKeys === void 0 || stored !== void 0 && sameReading(byKeys, stored.byKeys)) return void 0;
+  const { changed: changed2, left } = leftReading(written, stored);
+  if (sameReading(byKeys, left ?? DECIMAL)) return void 0;
   const keys2 = KEYS_BEFORE_NOTATION.flatMap((name) => written.keys[name] ? [`${name} ${JSON.stringify(written.keys[name])}`] : []);
-  return `"${key}" says ${readingWords(stated)} and ${keys2.join(", ")} say ${readingWords(byKeys)} \u2014 state "${key}" alone`;
+  if (changed2 !== void 0) {
+    const key = changed2 === "link" ? "link" : "notation";
+    return `"${key}" says ${readingWords(changed2)} and ${keys2.join(", ")} ${keys2.length === 1 ? "says" : "say"} ${readingWords(byKeys)}, and the keys before "notation" are no longer read \u2014 state "${key}" alone`;
+  }
+  const state = byKeys === "link" ? '"link": true' : `"notation": ${JSON.stringify(byKeys)}`;
+  return `${keys2.join(", ")} ${keys2.length === 1 ? "is" : "are"} no longer read \u2014 state ${state}`;
+}
+function settledReading(written, stored) {
+  const refused = keysRefusal(written, stored);
+  if (refused !== void 0) return { refusal: refused };
+  return checkedReading(leftReading(written, stored).left ?? written.byKeys, stored === void 0 ? void 0 : heldReading(stored));
 }
 function checkedReading(reading, held2) {
   const refused = changedCurrencyRefusal(reading, held2);
@@ -24900,7 +24955,7 @@ function figureIssue(path) {
     for (const { key, message: message2 } of figureKeysRefusals(value)) ctx.addIssue({ code: "custom", message: message2, path: [...path, key] });
   };
 }
-var BEFORE_NOTATION = 'Before "notation", and read as it: state "notation" instead.';
+var BEFORE_NOTATION = 'Replaced by "notation", and never read: naming another reading in it is refused.';
 function notationStatedIssue(path) {
   return (value, ctx) => {
     if (value.notation === void 0) return;
@@ -27330,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":
@@ -27377,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);
@@ -27390,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 {
@@ -27403,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) {
@@ -27432,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:
@@ -27461,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 = {
@@ -27531,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":
@@ -27550,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(
@@ -27563,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(
@@ -27665,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) {
@@ -27751,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;
@@ -27761,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.`,
@@ -27779,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" }
   );
 }
@@ -27790,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" }
     );
   }
@@ -27804,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(
@@ -27822,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;
@@ -27843,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;
 }
@@ -27874,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) {
@@ -27900,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":
@@ -27917,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":
@@ -27944,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;
 }
@@ -27979,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);
@@ -28002,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) {
@@ -28018,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
@@ -28079,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);
       }
     }
   );
@@ -28088,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);
     }
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lotics/app-sdk",
-  "version": "0.115.1",
+  "version": "0.115.3",
   "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": {