@lotics/app-sdk 0.121.0 → 0.122.1

package/dist/index.js

@@ -1848,13 +1848,16 @@ async function callEach(arr, cb) {
   let next = 0;
   let failed = false;
   const work = async () => {
-    while (!failed && next < arr.length) {
+    while (next < arr.length && !failed) {
       const i = next;
       next += 1;
-      results[i] = await Promise.resolve().then(() => cb(arr[i], i)).catch((error51) => {
+      try {
+        const result = cb(arr[i], i);
+        results[i] = result instanceof Promise ? await result : result;
+      } catch (error51) {
         failed = true;
         throw error51;
-      });
+      }
     }
   };
   const extra = arr.length > 1 ? cb.workers?.claim(arr.length - 1) ?? 0 : 0;
@@ -2047,7 +2050,8 @@ function find(arr, fieldOrCb, value) {
 }
 async function findByCallback(arr, cb) {
   for (let i = 0; i < arr.length; i++) {
-    if (await cb(arr[i], i)) return arr[i];
+    const hit = cb(arr[i], i);
+    if (hit instanceof Promise ? await hit : hit) return arr[i];
   }
   return void 0;
 }
@@ -2283,7 +2287,8 @@ function some(arr, fieldOrCb, value) {
     assertCallbackInput("some", arr);
     return (async () => {
       for (let i = 0; i < arr.length; i++) {
-        if (await fieldOrCb(arr[i], i)) return true;
+        const hit = fieldOrCb(arr[i], i);
+        if (hit instanceof Promise ? await hit : hit) return true;
       }
       return false;
     })();
@@ -2303,7 +2308,8 @@ function every(arr, fieldOrCb, value) {
     assertCallbackInput("every", arr);
     return (async () => {
       for (let i = 0; i < arr.length; i++) {
-        if (!await fieldOrCb(arr[i], i)) return false;
+        const hit = fieldOrCb(arr[i], i);
+        if (!(hit instanceof Promise ? await hit : hit)) return false;
       }
       return true;
     })();
@@ -2398,7 +2404,8 @@ async function reduce(arr, callback, initial) {
   assertCallbackInput("reduce", arr);
   let acc = initial;
   for (let i = 0; i < arr.length; i++) {
-    acc = await callback(acc, arr[i], i);
+    const next = callback(acc, arr[i], i);
+    acc = next instanceof Promise ? await next : next;
   }
   return acc;
 }
@@ -6121,11 +6128,9 @@ var HELPER_COST = {
   typeOf: "reads"
 };
 function helperCost(name) {
-  return isHelperName(name) ? HELPER_COST[name] : "builds";
-}
-function isHelperName(name) {
-  return Object.prototype.hasOwnProperty.call(HELPER_COST, name);
+  return HELPER_COST_BY_NAME.get(name) ?? "builds";
 }
+var HELPER_COST_BY_NAME = new Map(Object.entries(HELPER_COST));
 function createTimezoneAwareFunctions(defaultTimezone) {
   return {
     // Number functions
@@ -27376,7 +27381,11 @@ function resolveLambdaItemFrame(frames, name) {
   }
   return void 0;
 }
+function lambdaItemAnchor(ctx, name) {
+  return resolveLambdaItemFrame(ctx.lambda_items, name)?.anchor ?? null;
+}
 function readRecordAnchor(source, path, ctx) {
+  if (source.from === "lambda_param") return lambdaItemAnchor(ctx, source.name);
   return anchorForRead(source, path, ctx, /* @__PURE__ */ new Set());
 }
 function anchorForRead(source, path, ctx, seen) {
@@ -27386,7 +27395,7 @@ function anchorForRead(source, path, ctx, seen) {
     case "foreach_item":
       return resolveNamedForeachFrame(ctx.foreach_items, source.name)?.anchor ?? null;
     case "lambda_param":
-      return resolveLambdaItemFrame(ctx.lambda_items, source.name)?.anchor ?? null;
+      return lambdaItemAnchor(ctx, source.name);
     case "trigger_record":
       return rootAnchor(ctx.trigger_record);
     case "trigger_record_prev":
@@ -27697,7 +27706,7 @@ function assertCheap(budget, ...values2) {
 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 (readsClock(ctx) && 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);
@@ -27716,8 +27725,8 @@ function callbackWorkers() {
   };
 }
 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(() => {
+  const budget = { workers: callbackWorkers(), bounded: options.bounded === true, built: 0, clock_checks: 0, helpers: /* @__PURE__ */ new Map(), settled: false };
+  return evaluateRoot(expr2, { ...ctx, evaluation_budget: budget, anchor_context: evalAnchorContext(ctx) }).finally(() => {
     budget.settled = true;
   }).then((answer) => {
     if (budget.bounded && expandedSize(answer, MAX_IN_PLACE_BYTES) > MAX_IN_PLACE_BYTES) throw new ExpressionNotCheapError();
@@ -27727,8 +27736,19 @@ function evaluateWorkflowExpression(expr2, ctx, options = {}) {
     throw error51;
   });
 }
-async function evaluateExpression(expr2, ctx) {
+async function evaluateRoot(expr2, ctx) {
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
+  return evaluateExpression(expr2, ctx);
+}
+function failBeside(error51, started) {
+  void Promise.allSettled(started);
+  throw error51;
+}
+async function startBeside(expr2, ctx) {
+  return evaluateExpression(expr2, ctx);
+}
+function evaluateExpression(expr2, ctx) {
+  assertUnsettled(ctx.evaluation_budget);
   switch (expr2.kind) {
     case "lit":
       return expr2.value;
@@ -27741,31 +27761,75 @@ async function evaluateExpression(expr2, ctx) {
     case "unary":
       return evaluateUnary(expr2.op, expr2.arg, ctx);
     case "ternary": {
-      const cond = await evaluateExpression(expr2.cond, ctx);
-      return cond ? evaluateExpression(expr2.then, ctx) : evaluateExpression(expr2.else, ctx);
+      const cond = evaluateExpression(expr2.cond, ctx);
+      return cond instanceof Promise ? branchAfter(cond, expr2.then, expr2.else, ctx) : evaluateExpression(cond ? expr2.then : expr2.else, ctx);
     }
     case "template":
       return evaluateTemplate(expr2.parts, ctx);
     case "lambda":
       return evaluateLambda(expr2.params, expr2.body, ctx, []);
-    case "array_literal": {
-      const elements = await Promise.all(expr2.elements.map((el) => evaluateExpression(el, ctx)));
-      charge(ctx, builtSize(elements));
-      return elements;
-    }
-    case "object_literal": {
-      const out = {};
-      for (const entry of expr2.entries) defineOwn(out, entry.key, await evaluateExpression(entry.value, ctx));
-      charge(ctx, builtSize(out));
-      return out;
-    }
+    case "array_literal":
+      return evaluateArrayLiteral(expr2.elements, ctx);
+    case "object_literal":
+      return fillObjectLiteral({}, expr2.entries, 0, ctx);
     default:
       return assertNever(expr2);
   }
 }
+async function branchAfter(cond, then, otherwise, ctx) {
+  return evaluateExpression(await cond ? then : otherwise, ctx);
+}
+function evaluateArrayLiteral(elements, ctx) {
+  const values2 = [];
+  let pending = false;
+  try {
+    for (const element of elements) {
+      const value = evaluateExpression(element, ctx);
+      if (value instanceof Promise) pending = true;
+      values2.push(value);
+    }
+  } catch (error51) {
+    return failBeside(error51, values2);
+  }
+  return pending ? chargeAfter(values2, ctx) : chargedArray(values2, ctx);
+}
+async function chargeAfter(values2, ctx) {
+  return chargedArray(await Promise.all(values2), ctx);
+}
+function chargedArray(elements, ctx) {
+  charge(ctx, builtSize(elements));
+  return elements;
+}
+function fillObjectLiteral(out, entries3, from, ctx) {
+  for (let at2 = from; at2 < entries3.length; at2++) {
+    const entry = entries3[at2];
+    const value = evaluateExpression(entry.value, ctx);
+    if (value instanceof Promise) return fillObjectAfter(out, entries3, at2, value, ctx);
+    defineOwn(out, entry.key, value);
+  }
+  charge(ctx, builtSize(out));
+  return out;
+}
+async function fillObjectAfter(out, entries3, at2, value, ctx) {
+  defineOwn(out, entries3[at2].key, await value);
+  return fillObjectLiteral(out, entries3, at2 + 1, ctx);
+}
 function checkClock(ctx) {
   assertUnsettled(ctx.evaluation_budget);
-  return runClock(ctx.run_budget);
+  return readsClock(ctx) ? runClock(ctx.run_budget) : null;
+}
+var ISOLATED_CLOCK_STRIDE = 16;
+function readsClock(ctx) {
+  if (ctx.run_budget.host === "shared") return true;
+  const budget = ctx.evaluation_budget;
+  budget.clock_checks += 1;
+  if (budget.clock_checks % ISOLATED_CLOCK_STRIDE !== 1) return false;
+  if (budget.clock_checks === 1) {
+    queueMicrotask(() => {
+      budget.clock_checks = 0;
+    });
+  }
+  return true;
 }
 function assertUnsettled(budget) {
   if (budget.settled) {
@@ -27775,21 +27839,19 @@ function assertUnsettled(budget) {
   }
 }
 function evaluateLambda(params, body, ctx, items) {
-  const call = async (...args) => {
-    const frame2 = {};
-    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 = {
-      ...ctx,
-      lambda_params: newStack,
-      // The VALUE frame and the ANCHOR frames are pushed together: a body that
-      // can read the item must read it through the same table the save layer
-      // typed it with, and a parameter that is not the item must shadow an
-      // outer one of the same name in both stacks alike.
-      lambda_items: items.length === 0 ? ctx.lambda_items : [...ctx.lambda_items ?? [], ...items]
-    };
-    return evaluateExpression(body, innerCtx);
+  const lambdaItems = items.length === 0 ? ctx.lambda_items : [...ctx.lambda_items ?? [], ...items];
+  const bodyCtx = {
+    ...ctx,
+    lambda_items: lambdaItems,
+    anchor_context: { ...ctx.anchor_context, lambda_items: lambdaItems ?? [] }
+  };
+  const stack = ctx.lambda_params ?? [];
+  const call = (...args) => {
+    const pause = checkClock(bodyCtx);
+    if (pause !== null) return pause.then(() => call(...args));
+    const frame2 = /* @__PURE__ */ Object.create(null);
+    for (let i = 0; i < params.length; i++) frame2[params[i]] = args[i];
+    return evaluateExpression(body, { ...bodyCtx, lambda_params: [...stack, frame2] });
   };
   return Object.assign(call, { workers: ctx.evaluation_budget.workers });
 }
@@ -27809,9 +27871,6 @@ function evalAnchorContext(ctx) {
     trigger_changes: ctx.trigger_table
   };
 }
-function resolveReadAnchor(source, path, ctx) {
-  return readRecordAnchor(source, path, evalAnchorContext(ctx));
-}
 function resolveReadRoot(source, ctx) {
   switch (source.from) {
     case "trigger":
@@ -27921,29 +27980,37 @@ function resolveForeachFrame(ctx, name, at2) {
     { kind: "read", at: at2, extra: { name } }
   );
 }
-async function evaluateRead(source, path, coerce, ctx) {
-  let current = source.from === "value" ? await evaluateExpression(source.expr, ctx) : resolveReadRoot(source, ctx);
-  const anchor = resolveReadAnchor(source, path, ctx);
-  let currentTable = null;
-  let prevFieldForSegment;
-  let terminalField;
-  for (let i = 0; i < path.length; i++) {
+function evaluateRead(source, path, coerce, ctx) {
+  const root = source.from === "value" ? evaluateExpression(source.expr, ctx) : resolveReadRoot(source, ctx);
+  return root instanceof Promise ? readAfter(root, source, path, coerce, ctx) : walkPath(path, coerce, ctx, readRecordAnchor(source, path, ctx.anchor_context), 0, root, null, void 0, void 0);
+}
+async function readAfter(root, source, path, coerce, ctx) {
+  const value = await root;
+  return walkPath(path, coerce, ctx, readRecordAnchor(source, path, ctx.anchor_context), 0, value, null, void 0, void 0);
+}
+function walkPath(path, coerce, ctx, anchor, from, start, startTable, startField, startTerminal) {
+  let current = start;
+  let table = startTable;
+  let prevField = startField;
+  let terminalField = startTerminal;
+  for (let i = from; i < path.length; i++) {
     const segment = path[i];
     const isLast = i === path.length - 1;
-    if (anchor && i === anchor.envelopeLen) currentTable ??= anchor.table;
+    if (anchor && i === anchor.envelopeLen) table ??= anchor.table;
     const carried = carriedTable(current, ctx);
-    if (carried?.at === "self") currentTable = carried.table;
-    const fieldForSegment = (segment.at === "field" || segment.at === "key") && currentTable ? findField(currentTable, segment.key) : void 0;
+    if (carried?.at === "self") table = carried.table;
+    const field = (segment.at === "field" || segment.at === "key") && table ? findField(table, segment.key) : void 0;
     if (isLast) {
-      terminalField = fieldForSegment ?? (segment.at === "key" && (segment.key === "next_value" || segment.key === "prev_value") ? prevFieldForSegment : void 0);
+      terminalField = field ?? (segment.at === "key" && (segment.key === "next_value" || segment.key === "prev_value") ? prevField : void 0);
     }
-    current = await walkSegment(current, segment, ctx);
-    currentTable = advanceTable(segment, currentTable, ctx);
-    if (carried?.at === "data" && isKeyNamed(segment, "data")) currentTable = carried.table;
-    prevFieldForSegment = fieldForSegment;
-    if (current === void 0 || current === null) {
-      return current;
+    const walked = walkSegment(current, segment, ctx);
+    if (walked instanceof Promise) {
+      return walkPending({ path, coerce, ctx, anchor, table, carried, field, terminal_field: terminalField }, i, walked);
     }
+    table = tableAfter(segment, table, carried, ctx);
+    prevField = field;
+    current = walked;
+    if (current === void 0 || current === null) return current;
   }
   if (terminalField && isScalarWrappedField(terminalField)) {
     current = unwrapScalarField(current);
@@ -27953,6 +28020,17 @@ async function evaluateRead(source, path, coerce, ctx) {
   }
   return current;
 }
+async function walkPending(read2, at2, walked) {
+  const { path, coerce, ctx, anchor, carried, field, terminal_field: terminalField } = read2;
+  const current = await walked;
+  if (current === void 0 || current === null) return current;
+  const table = tableAfter(path[at2], read2.table, carried, ctx);
+  return walkPath(path, coerce, ctx, anchor, at2 + 1, current, table, field, terminalField);
+}
+function tableAfter(segment, table, carried, ctx) {
+  const advanced = advanceTable(segment, table, ctx);
+  return carried?.at === "data" && isKeyNamed(segment, "data") ? carried.table : advanced;
+}
 function isScalarWrappedField(field) {
   if (field.type === "formula") return field.formula.options !== void 0;
   return (field.type === "select" || field.type === "select_member") && field.multi !== true;
@@ -28058,7 +28136,7 @@ function advanceTable(segment, currentTable, ctx) {
 function findField(table, fieldKey) {
   return table.fields.find((f) => f.key === fieldKey);
 }
-async function walkSegment(value, segment, ctx) {
+function walkSegment(value, segment, ctx) {
   switch (segment.at) {
     case "key":
     case "field": {
@@ -28079,12 +28157,14 @@ async function walkSegment(value, segment, ctx) {
     case "index": {
       if (value === null || value === void 0) return void 0;
       if (Array.isArray(value) || typeof value === "string") {
-        const idx = typeof segment.index === "number" ? segment.index : await resolveIndexExpression(segment.index, ctx, "array index");
-        return value[idx];
+        if (typeof segment.index === "number") return value[segment.index];
+        const idx = resolveIndexExpression(segment.index, ctx, "array index");
+        return idx instanceof Promise ? idx.then((at2) => value[at2]) : value[idx];
       }
       if (typeof value === "object") {
-        const key = typeof segment.index === "number" ? String(segment.index) : await resolveObjectKeyExpression(segment.index, ctx);
-        return ownMember(value, key);
+        if (typeof segment.index === "number") return ownMember(value, String(segment.index));
+        const key = resolveObjectKeyExpression(segment.index, ctx);
+        return key instanceof Promise ? key.then((named) => ownMember(value, named)) : ownMember(value, key);
       }
       throw new WorkflowEvalError(
         `Cannot index ${typeof value} \u2014 only an array or an object can be read by index.`,
@@ -28095,8 +28175,11 @@ async function walkSegment(value, segment, ctx) {
       return walkLinked(value, segment, ctx);
   }
 }
-async function resolveObjectKeyExpression(expr2, ctx) {
-  const value = await evaluateExpression(expr2, ctx);
+function resolveObjectKeyExpression(expr2, ctx) {
+  const value = evaluateExpression(expr2, ctx);
+  return value instanceof Promise ? value.then(objectKey) : objectKey(value);
+}
+function objectKey(value) {
   if (typeof value === "string") return value;
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
   throw new WorkflowEvalError(
@@ -28108,8 +28191,11 @@ async function resolveObjectKeyExpression(expr2, ctx) {
   );
 }
 var VALUE_PREVIEW_LENGTH = 120;
-async function resolveIndexExpression(expr2, ctx, context) {
-  const value = await evaluateExpression(expr2, ctx);
+function resolveIndexExpression(expr2, ctx, context) {
+  const value = evaluateExpression(expr2, ctx);
+  return value instanceof Promise ? value.then((settled) => arrayIndex(settled, context)) : arrayIndex(value, context);
+}
+function arrayIndex(value, context) {
   if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
     throw new WorkflowEvalError(
       `Computed ${context} must evaluate to a non-negative integer, got ${describeValue(value)}`,
@@ -28181,46 +28267,77 @@ async function fetchRecordsBounded(ids, reading, ctx) {
   }
   return results;
 }
-async function evaluateCall(fn, args, ctx) {
+function evaluateCall(fn, args, ctx) {
+  const pause = checkClock(ctx);
+  if (pause !== null) return pause.then(() => evaluateCall(fn, args, ctx));
+  const helper = resolveHelper(fn, ctx);
+  const values2 = [];
+  let pending = false;
+  try {
+    for (const arg of args) {
+      const value = arg.kind === "lambda" ? evaluateLambda(arg.params, arg.body, ctx, callbackItemFrames(fn, args, arg.params, ctx.anchor_context)) : evaluateExpression(arg, ctx);
+      if (value instanceof Promise) pending = true;
+      values2.push(value);
+    }
+  } catch (error51) {
+    return failBeside(error51, values2);
+  }
+  return pending ? callAfter(helper, values2, ctx) : callHelper(helper, values2, ctx);
+}
+function resolveHelper(fn, ctx) {
+  const known = ctx.evaluation_budget.helpers.get(fn);
+  if (known !== void 0) return known;
   if (!Object.prototype.hasOwnProperty.call(ctx.helpers, fn)) {
     throw new WorkflowEvalError(`Unknown helper function "${fn}"`, {
       kind: "call",
       extra: { fn }
     });
   }
-  const helper = ctx.helpers[fn];
-  const anchors = args.some((arg) => arg.kind === "lambda") ? evalAnchorContext(ctx) : null;
-  const evaluatedArgs = await Promise.all(
-    args.map(
-      (arg) => arg.kind === "lambda" && anchors !== null ? evaluateLambda(arg.params, arg.body, ctx, callbackItemFrames(fn, args, arg.params, anchors)) : evaluateExpression(arg, ctx)
-    )
-  );
+  const resolved = { call: ctx.helpers[fn], cost: helperCost(fn) };
+  ctx.evaluation_budget.helpers.set(fn, resolved);
+  return resolved;
+}
+async function callAfter(helper, pending, ctx) {
+  const values2 = await Promise.all(pending);
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
-  const cost = helperCost(fn);
-  if (cost === "parses") charge(ctx, parsedSize(evaluatedArgs[0]));
-  const answer = await helper(...evaluatedArgs);
+  return callHelper(helper, values2, ctx);
+}
+function callHelper({ call, cost }, values2, ctx) {
+  if (cost === "parses") charge(ctx, parsedSize(values2[0]));
+  const answer = Reflect.apply(call, void 0, values2);
+  return answer instanceof Promise ? chargeAnswerAfter(cost, answer, values2, ctx) : chargeAnswer(cost, answer, values2, ctx);
+}
+async function chargeAnswerAfter(cost, answer, values2, ctx) {
+  return chargeAnswer(cost, await answer, values2, ctx);
+}
+function chargeAnswer(cost, answer, values2, ctx) {
   if (cost !== "builds" && cost !== "nested") return answer;
-  const handedBack = evaluatedArgs.indexOf(answer);
-  if (handedBack !== -1) return evaluatedArgs[handedBack];
-  charge(ctx, builtSize(answer) + (cost === "nested" ? builtSize(evaluatedArgs[0]) : 0));
+  const handedBack = values2.indexOf(answer);
+  if (handedBack !== -1) return values2[handedBack];
+  charge(ctx, builtSize(answer) + (cost === "nested" ? builtSize(values2[0]) : 0));
   return answer;
 }
-async function evaluateBinary(op, leftExpr, rightExpr, ctx) {
-  if (op === "and") {
-    const left2 = await evaluateExpression(leftExpr, ctx);
-    if (!left2) return left2;
-    return evaluateExpression(rightExpr, ctx);
-  }
-  if (op === "or") {
-    const left2 = await evaluateExpression(leftExpr, ctx);
-    if (left2) return left2;
-    return evaluateExpression(rightExpr, ctx);
-  }
-  const [left, right] = await Promise.all([
-    evaluateExpression(leftExpr, ctx),
-    evaluateExpression(rightExpr, ctx)
-  ]);
+function evaluateBinary(op, leftExpr, rightExpr, ctx) {
+  if (op === "and" || op === "or") {
+    const first2 = evaluateExpression(leftExpr, ctx);
+    return first2 instanceof Promise ? shortCircuitAfter(first2, op, rightExpr, ctx) : shortCircuit(op, first2, rightExpr, ctx);
+  }
+  const left = evaluateExpression(leftExpr, ctx);
+  const right = left instanceof Promise ? startBeside(rightExpr, ctx) : evaluateExpression(rightExpr, ctx);
+  return left instanceof Promise || right instanceof Promise ? binaryAfter(op, left, right, ctx) : applyBinary(op, left, right, ctx);
+}
+function shortCircuit(op, left, rightExpr, ctx) {
+  return (op === "and" ? !left : left) ? left : evaluateExpression(rightExpr, ctx);
+}
+async function shortCircuitAfter(left, op, rightExpr, ctx) {
+  return shortCircuit(op, await left, rightExpr, ctx);
+}
+async function binaryAfter(op, left, right, ctx) {
+  const [leftValue, rightValue] = await Promise.all([left, right]);
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
+  return applyBinary(op, leftValue, rightValue, ctx);
+}
+function applyBinary(op, left, right, ctx) {
   switch (op) {
     case "eq":
     case "neq":
@@ -28327,8 +28444,14 @@ function describeValue(value) {
   }
   return value.length > 0 && length2 <= VALUE_PREVIEW_LENGTH ? `array ${value.join(",")}` : "array";
 }
-async function evaluateUnary(op, argExpr, ctx) {
-  const value = await evaluateExpression(argExpr, ctx);
+function evaluateUnary(op, argExpr, ctx) {
+  const value = evaluateExpression(argExpr, ctx);
+  return value instanceof Promise ? unaryAfter(op, value) : applyUnary(op, value);
+}
+async function unaryAfter(op, value) {
+  return applyUnary(op, await value);
+}
+function applyUnary(op, value) {
   switch (op) {
     case "not":
       return !value;
@@ -28342,11 +28465,26 @@ async function evaluateUnary(op, argExpr, ctx) {
       return -value;
   }
 }
-async function evaluateTemplate(parts, ctx) {
-  const evaluated2 = await Promise.all(
-    parts.map((part) => part.t === "text" ? part.s : evaluateExpression(part.e, ctx))
-  );
+function evaluateTemplate(parts, ctx) {
+  const evaluated2 = [];
+  let pending = false;
+  try {
+    for (const part of parts) {
+      const value = part.t === "text" ? part.s : evaluateExpression(part.e, ctx);
+      if (value instanceof Promise) pending = true;
+      evaluated2.push(value);
+    }
+  } catch (error51) {
+    return failBeside(error51, evaluated2);
+  }
+  return pending ? templateAfter(evaluated2, ctx) : writeTemplate(evaluated2, ctx);
+}
+async function templateAfter(pending, ctx) {
+  const evaluated2 = await Promise.all(pending);
   for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
+  return writeTemplate(evaluated2, ctx);
+}
+function writeTemplate(evaluated2, ctx) {
   assertCheap(ctx.evaluation_budget, ...evaluated2);
   assertTextWithin("template", ...evaluated2);
   const text2 = evaluated2.map(stringifyForTemplate).join("");

package/docs/queries.md

@@ -142,7 +142,7 @@ Delivery-layer enrichment (applied to the response, per request):
   (`readSelect(cell).map((o) => o.key)`) against any alias that projects the underlying field
   DIRECTLY.
 - **`number` columns** arrive as JS numbers (Postgres `numeric` strings are coerced; a
-  high-precision decimal that would lose digits stays a string). **`date`/`datetime`** columns
+  decimal with more digits than a double holds rounds to the double). **`date`/`datetime`** columns
   arrive as canonical wall-clock strings (`YYYY-MM-DD` / `YYYY-MM-DDTHH:mm`).
 
 ### System columns

package/package.json

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