@lotics/app-sdk 0.114.0 → 0.115.1

package/dist/index.js

@@ -21561,6 +21561,180 @@ function validateFieldTypeForOperation(fieldType, operation, subject) {
   throw new Error(`Operation '${operation}' is not valid for field type '${fieldType}'`);
 }
 
+// ../shared/src/schemas/iam.ts
+var jsonSchemaSchema = zod_default.string();
+var organizationSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the organization"),
+  name: zod_default.string().describe("Display name of the organization"),
+  slug: zod_default.string().nullable().describe("Slug for the organization")
+});
+var memberAccountTypeSchema = zod_default.enum(["self_managed", "admin_managed", "service"]).describe(
+  "How the account is credentialed. admin_managed means an admin chose the sign-in name and set the password; the account has NO email address at all, so nothing can be mailed to it until the member claims one they control. service means no credential exists at all \u2014 the membership is an integration's identity, reached only by an API key bound to it."
+);
+var ALL_ACCOUNT_TYPES = memberAccountTypeSchema.options;
+var memberSchema = zod_default.object({
+  member_id: zod_default.string().describe("Unique identifier for the member"),
+  organization_id: zod_default.string().describe("Organization ID the member belongs to"),
+  name: zod_default.string().describe("Display name of the member"),
+  email_address: zod_default.string().nullable().describe(
+    "What the member types to sign in: an email address for a self-managed member, an administrator-issued name (e.g. giamdoc.sunrise) for an admin-managed one. The latter is NOT an address and cannot receive mail \u2014 the field name predates the split. Null for a service identity, which holds no credential and signs in nowhere."
+  ),
+  role: zod_default.enum(["owner", "admin", "member"]).describe("Organization role"),
+  image: zod_default.string().nullable().optional().describe("URL to the member's profile picture"),
+  account_type: memberAccountTypeSchema,
+  archived: zod_default.boolean().optional().describe(
+    "True when this person has been removed from the organization. The membership survives removal so records naming them keep resolving; it grants nothing. Optional because an older server omits it \u2014 absent means active."
+  ),
+  joined_at: zod_default.string().optional().describe(
+    "ISO timestamp of when this membership began. Optional because an older server omits it \u2014 absent means not told, never 'joined at the epoch'."
+  )
+});
+var pendingInvitationSchema = zod_default.object({
+  invitation_id: zod_default.string().describe("Unique identifier for the pending invitation"),
+  organization_id: zod_default.string().describe("Organization the invitee will join on accept"),
+  email: zod_default.string().describe("Email the invitation was sent to"),
+  name: zod_default.string().nullable().describe("Admin-supplied display name (carried onto member.name on accept; invitee can override at accept time)"),
+  role: zod_default.enum(["owner", "admin", "member"]).describe("Role the invitee will receive on accept"),
+  expires_at: zod_default.string().describe("ISO timestamp when the invitation expires")
+});
+var ianaTimezoneSchema = zod_default.string().refine(
+  (tz) => {
+    try {
+      new Intl.DateTimeFormat("en-US", { timeZone: tz });
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  { message: "must be an IANA timezone name, e.g. Asia/Ho_Chi_Minh or America/New_York" }
+).describe("IANA timezone name (e.g., 'America/New_York', 'Asia/Ho_Chi_Minh')");
+var currencyCodeSchema = zod_default.string().trim().toUpperCase().regex(/^[A-Z]{3}$/, "must be an ISO 4217 currency code, e.g. VND, USD, EUR").describe("ISO 4217 currency code (e.g. 'VND', 'USD', 'EUR'). Upper-cased.");
+var workspaceSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the workspace"),
+  name: zod_default.string().describe("Display name of the workspace"),
+  default_currency: zod_default.string().describe("Default currency code for the workspace"),
+  // Plain string on the way OUT, deliberately. This is a response schema, so
+  // validating here would make the server reject its own stored rows — and on
+  // the workspace LIST one bad row fails the entire array. The zone is enforced
+  // where it is written; a read is too late to do anything about it anyway.
+  timezone: zod_default.string().describe("IANA timezone name (e.g., 'America/New_York', 'Asia/Ho_Chi_Minh')"),
+  organization_id: zod_default.string().describe("Organization ID this workspace belongs to"),
+  created_at: zod_default.string().describe("Timestamp when workspace was created")
+});
+var memberGroupSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the member group"),
+  name: zod_default.string().describe("Display name of the group"),
+  description: zod_default.string().optional().describe("Optional description of the group's purpose"),
+  member_ids: zod_default.array(zod_default.string()).describe("Array of member IDs in this group"),
+  invitation_ids: zod_default.array(zod_default.string()).describe("Array of pending invitation IDs pre-granted membership; migrated to member_ids on accept"),
+  organization_id: zod_default.string().describe("ID of the organization this group belongs to"),
+  created_at: zod_default.string().describe("Timestamp when group was created"),
+  created_by: zod_default.string().describe("Member ID of the user who created this group")
+});
+var principalGroupSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the member group"),
+  name: zod_default.string().describe("Display name of the group"),
+  description: zod_default.string().optional().describe("Optional description of the group's purpose"),
+  member_count: zod_default.number().int().describe("Number of accepted members in the group"),
+  invitation_count: zod_default.number().int().describe("Number of pending invitations pre-granted membership")
+});
+var PUBLIC_PRINCIPAL_ID = "public";
+var principalSchema = zod_default.discriminatedUnion("type", [
+  zod_default.object({
+    type: zod_default.literal("member").describe("Principal type: individual member"),
+    id: zod_default.string().describe("Member ID")
+  }),
+  zod_default.object({
+    type: zod_default.literal("member_group").describe("Principal type: group of members"),
+    id: zod_default.string().describe("Member group ID")
+  }),
+  zod_default.object({
+    type: zod_default.literal("organization").describe("Principal type: all members in organization"),
+    id: zod_default.string().describe("Organization ID")
+  }),
+  zod_default.object({
+    type: zod_default.literal("public").describe("Principal type: anyone, including unauthenticated visitors"),
+    id: zod_default.literal(PUBLIC_PRINCIPAL_ID).describe("Always the `public` sentinel \u2014 no entity")
+  }),
+  // Pending invitation as principal: lets admins pre-grant group membership and
+  // resource access before the invitee accepts. Never resolved as a Subject —
+  // a pending invitee cannot authenticate, so these bindings stay dormant until
+  // accept-time migration rewrites them to type:"member".
+  zod_default.object({
+    type: zod_default.literal("invitation").describe("Principal type: pending invitation (not yet accepted)"),
+    id: zod_default.string().describe("Invitation ID")
+  })
+]);
+var subjectSchema = zod_default.discriminatedUnion("type", [
+  zod_default.object({
+    type: zod_default.literal("member").describe("Subject type: authenticated member"),
+    id: zod_default.string().describe("Member ID")
+  }),
+  zod_default.object({
+    type: zod_default.literal("public").describe("Subject type: unauthenticated visitor")
+  })
+]);
+var resourceTypeSchema = zod_default.enum(["table", "table_view", "app", "automation", "skill", "document_template", "instruction", "knowledge_doc", "connected_account"]);
+var RESOURCE_ROLE_ACTIONS = {
+  table: {
+    editor: ["read_data", "write_data"],
+    viewer: ["read_data"]
+  },
+  app: { manager: ["use", "manage"], user: ["use"] },
+  skill: { manager: ["use", "manage"], user: ["use"] },
+  document_template: { manager: ["use", "manage"], user: ["use"] },
+  instruction: { manager: ["use", "manage"], user: ["use"] },
+  knowledge_doc: { manager: ["use", "manage"], user: ["use"] },
+  connected_account: { manager: ["use", "manage"], user: ["use"] },
+  table_view: {},
+  automation: {}
+};
+function shareableRolesFor(type) {
+  return Object.keys(RESOURCE_ROLE_ACTIONS[type]);
+}
+var SHAREABLE_RESOURCE_TYPES = resourceTypeSchema.options.filter(
+  (type) => shareableRolesFor(type).length > 0
+);
+var accessPrincipalSchema = zod_default.discriminatedUnion("type", [
+  zod_default.object({
+    type: zod_default.literal("member").describe("Principal type: an individual member"),
+    id: zod_default.string().describe("Member ID")
+  }),
+  zod_default.object({
+    type: zod_default.literal("member_group").describe("Principal type: a member group"),
+    id: zod_default.string().describe("Group ID")
+  }),
+  zod_default.object({
+    type: zod_default.literal("organization").describe("Principal type: everyone in the organization"),
+    id: zod_default.string().describe("Organization ID")
+  })
+]);
+var resourceAccessSchema = zod_default.object({
+  resource_id: zod_default.string().describe("ID of the resource these principals can reach"),
+  principals: zod_default.array(accessPrincipalSchema).describe("Members, groups and the organization that have been granted access")
+});
+var contentResourceTypeSchema = zod_default.enum(["knowledge_doc", "document_template"]);
+var contentItemSchema = zod_default.object({
+  id: zod_default.string().describe("ID of the knowledge doc or template"),
+  name: zod_default.string().describe("Its name"),
+  owner_member_id: zod_default.string().nullable().describe("Member who owns it; null when nobody does"),
+  created_at: zod_default.string().describe("When it was created"),
+  updated_at: zod_default.string().nullable().describe("When a knowledge doc was last changed; null for a template"),
+  hidden_at: zod_default.string().nullable().describe("When a knowledge doc was hidden; null when it is in use, and for a template"),
+  template_type: zod_default.string().nullable().describe("A template's type (html, email, word, excel, pdf-form); null for a knowledge doc"),
+  can_open: zod_default.boolean().describe("Whether the caller may open it; false means it is not shared with them"),
+  principals: zod_default.array(accessPrincipalSchema).describe("Members, groups and the organization it has been shared with, besides its owner")
+});
+var resourceRoleBindingSchema = zod_default.object({
+  id: zod_default.string().describe("Unique identifier for the role binding"),
+  principal: principalSchema.describe(
+    "Who this role binding applies to (member, group, or organization)"
+  ),
+  resource_type: resourceTypeSchema.describe("Type of resource being accessed"),
+  resource_id: zod_default.string().describe("ID of the specific resource"),
+  role: zod_default.string().describe("Role name (e.g., 'viewer', 'editor', 'manager', 'user')")
+});
+
 // ../shared/src/number_unit.ts
 var MEASURED_UNITS = [
   { code: "g", dimension: "mass", factor: 1, label: { vi: "g", en: "g" }, scales: true, spellings: ["gram", "grams", "gam"] },
@@ -21579,9 +21753,11 @@ var MEASURED_UNITS = [
   { code: "day", dimension: "duration", factor: 1440, label: { vi: "ng\xE0y", en: "d" }, scales: true, spellings: ["days"] }
 ];
 var COUNTED_UNIT_MAX_LENGTH = 12;
-var UNIT_DESCRIPTION = `What a plain figure counts or measures, drawn after it: a measured code (${MEASURED_UNITS.map((unit) => unit.code).join(", ")}), which converts and scales within its dimension, or any other noun of at most ${COUNTED_UNIT_MAX_LENGTH} characters (ki\u1EC7n, pallet, TEU), which never does. Only beside format "number".`;
+var UNIT_WORDS = `a measured code (${MEASURED_UNITS.map((unit) => unit.code).join(", ")}), which converts and scales within its dimension, or any other noun of at most ${COUNTED_UNIT_MAX_LENGTH} characters (ki\u1EC7n, pallet, TEU), which never does`;
+var UNIT_DESCRIPTION = `What a plain figure counts or measures, drawn after it: ${UNIT_WORDS}. Only beside format "number".`;
 var UNIT_FIELD_DESCRIPTION = 'A single select on the same row, or a lookup of one through a one-link, whose chosen option is that row\'s unit: every option label is a unit as `unit` takes one. In place of `unit`; only beside format "number".';
 var CURRENCY_FIELD_DESCRIPTION = 'A single select on the same row, or a lookup of one through a one-link, whose chosen option is that row\'s currency: every option label is an ISO 4217 code. In place of `currency`; only beside format "currency".';
+var DEFAULT_CURRENCY = "VND";
 function unitKey(text2) {
   return text2.normalize("NFC").trim().toLocaleLowerCase("vi").replace(/\s+/g, " ");
 }
@@ -21619,88 +21795,151 @@ function numberUnitRefusal(format2, unit) {
   if (format2 !== void 0 && format2 !== "number") {
     return `a unit is for a plain figure (format "number"), not "${format2}": money states its currency and a percent its sign`;
   }
+  return unitRefusalWords(unit);
+}
+function unitRefusalWords(unit) {
   const refusal = unitRefusal(unit);
   return refusal === void 0 ? void 0 : refusalWords(unit, refusal);
 }
-
-// ../shared/src/select_option_enrichment.ts
-function effectiveSelectOptions(field) {
-  if (field === void 0) return null;
-  if (field.type === "select") return field.options ?? null;
-  if (field.type === "formula") return field.formula?.options ?? null;
-  if (field.type === "lookup" && field.lookup_field_type === "select") {
-    return field.lookup_field_options ?? null;
-  }
-  return null;
+function currencyCodeRefusal(code) {
+  if (Intl.supportedValuesOf("currency").includes(code)) return void 0;
+  const coded = currencyCodeOf(code);
+  return coded !== void 0 ? `a currency is written as its ISO 4217 code: "${coded}"` : `"${code}" is not an ISO 4217 currency code (USD, EUR, VND)`;
+}
+var DONG_SPELLINGS = ["vn\u0111", "\u0111", "\u20AB", "\u0111\u1ED3ng"];
+function currencyCodeOf(written) {
+  const upper2 = written.trim().toUpperCase();
+  if (Intl.supportedValuesOf("currency").includes(upper2)) return upper2;
+  return DONG_SPELLINGS.includes(unitKey(written)) ? "VND" : void 0;
+}
+var EXACT_DIGITS = 15;
+function convert(value, from, to) {
+  return from.code === to.code ? value : Number((value * from.factor / to.factor).toPrecision(EXACT_DIGITS));
+}
+function scaleIn(own, pack) {
+  const kin = MEASURED_UNITS.filter((one) => one.dimension === own.dimension);
+  const rung = (one) => ({ label: one.label[pack], factor: convert(1, one, own) });
+  const names = (one) => [...SPELLED].filter(([, spelled]) => spelled.code === one.code).map(([name]) => name);
+  return {
+    label: own.label[pack],
+    ladder: own.scales ? kin.filter((one) => one.scales && one.factor >= own.factor).map(rung) : [rung(own)],
+    entries: [own, ...kin.filter((one) => one.code !== own.code)].map((one) => ({ ...rung(one), names: names(one) }))
+  };
 }
+var SCALES = new Map(
+  MEASURED_UNITS.map((unit) => [unit.code, { vi: scaleIn(unit, "vi"), en: scaleIn(unit, "en") }])
+);
 
-// ../shared/src/row_figure.ts
-function namedSelect(unitField, currencyField) {
-  if (unitField != null) return { vocabulary: "unit", key: unitField };
-  if (currencyField != null) return { vocabulary: "currency", key: currencyField };
-  return void 0;
+// ../shared/src/notation.ts
+var PERCENT = "percent";
+var DECIMAL = { style: "decimal" };
+var NOTATION_DESCRIPTION = `How the figure reads: { "style": "decimal" }; money, { "style": "currency", "currency": an ISO 4217 code (USD, VND) }; or a quantity, { "style": "unit", "unit": "${PERCENT}" (10 reads "10%"), or ${UNIT_WORDS} }. A currency or unit read on each row from a single select of that row is { "per_row": that select }.`;
+function unitIssue(unit, ctx) {
+  const refused = unit === PERCENT ? void 0 : unitRefusalWords(unit);
+  if (refused !== void 0) ctx.addIssue({ code: "custom", message: refused });
 }
-function figureRowSelect(field) {
+function notationSchemaOf(reference) {
+  const perRow = external_exports.object({ per_row: reference.describe("The single select of the same row whose option is each row's currency or unit") }).strict();
+  return external_exports.discriminatedUnion("style", [
+    external_exports.object({ style: external_exports.literal("decimal") }).strict(),
+    external_exports.object({ style: external_exports.literal("currency"), currency: external_exports.union([external_exports.string().min(1), perRow]) }).strict(),
+    external_exports.object({ style: external_exports.literal("unit"), unit: external_exports.union([external_exports.string().superRefine(unitIssue), perRow]) }).strict()
+  ]).describe(NOTATION_DESCRIPTION);
+}
+var notationSchema = notationSchemaOf(external_exports.string().min(1));
+function notationOfKeys(keys2) {
+  if (keys2.format === "currency") {
+    return { style: "currency", currency: keys2.currency_field ? { per_row: keys2.currency_field } : keys2.currency || DEFAULT_CURRENCY };
+  }
+  if (keys2.unit_field) return { style: "unit", unit: { per_row: keys2.unit_field } };
+  if (keys2.unit) return { style: "unit", unit: keys2.unit };
+  if (keys2.format === "percentage") return { style: "unit", unit: PERCENT };
+  return DECIMAL;
+}
+var KEYS_BEFORE_NOTATION = ["format", "currency", "unit", "unit_field", "currency_field"];
+function keysStated(keys2) {
+  return KEYS_BEFORE_NOTATION.some((key) => Boolean(keys2[key]));
+}
+function sameValue(a, b) {
+  return typeof a === "string" || typeof b === "string" ? a === b : a.per_row === b.per_row;
+}
+function sameNotation(a, b) {
+  if (a === void 0 || b === void 0) return a === b;
+  if (a.style === "currency" && b.style === "currency") return sameValue(a.currency, b.currency);
+  if (a.style === "unit" && b.style === "unit") return sameValue(a.unit, b.unit);
+  return a.style === "decimal" && b.style === "decimal";
+}
+function storedNotation(notation, keys2) {
+  if (notation == null) return notationOfKeys(keys2);
+  if (!keysStated(keys2)) return notation;
+  const derived = notationOfKeys(keys2);
+  return sameNotation(notation, derived) ? notation : derived;
+}
+function fieldNotation(field) {
   switch (field.type) {
     case "number":
-      return namedSelect(field.unit_field, field.currency_field);
+      return storedNotation(field.notation, field);
     case "formula": {
-      const output = field.formula?.output_type;
-      return output == null || output === "number" ? namedSelect(field.formula?.unit_field, field.formula?.currency_field) : void 0;
+      const formula = field.formula;
+      const output = formula?.output_type;
+      return output == null || output === "number" ? storedNotation(formula?.notation, formula ?? {}) : void 0;
     }
     case "rollup": {
       const operation = field.aggregate_option?.operation;
-      return isAggregateOperation(operation) && rollupOutputType(operation) === "number" ? namedSelect(field.aggregate_field_unit_field, field.aggregate_field_currency_field) : void 0;
+      if (!isAggregateOperation(operation) || rollupOutputType(operation) !== "number") return void 0;
+      return storedNotation(field.aggregate_field_notation, {
+        format: field.aggregate_field_format,
+        currency: field.aggregate_field_currency,
+        unit: field.aggregate_field_unit,
+        unit_field: field.aggregate_field_unit_field,
+        currency_field: field.aggregate_field_currency_field
+      });
     }
+    case "lookup":
+      return field.lookup_field_type === "number" ? storedNotation(field.lookup_field_notation, { format: field.lookup_field_format, currency: field.lookup_field_currency, unit: field.lookup_field_unit }) : void 0;
     default:
       return void 0;
   }
 }
-function firstOptionKey(cell) {
-  if (!Array.isArray(cell)) return void 0;
-  for (const entry of cell) {
-    if (typeof entry === "string") return entry;
-    const inner = firstOptionKey(entry);
-    if (inner !== void 0) return inner;
-  }
+function notationRowSelect(notation) {
+  if (notation?.style === "currency" && typeof notation.currency !== "string") return { vocabulary: "currency", key: notation.currency.per_row };
+  if (notation?.style === "unit" && typeof notation.unit !== "string") return { vocabulary: "unit", key: notation.unit.per_row };
   return void 0;
 }
-function comparesFigure(operator) {
-  return operator !== "is_empty" && operator !== "is_not_empty";
+function notationCurrency(notation) {
+  return notation?.style === "currency" && typeof notation.currency === "string" ? notation.currency : void 0;
 }
-function nameOf(field) {
-  return `"${field.name ?? field.key}"`;
+function notationSaid(figure) {
+  return { stated: figure.notation ?? void 0, byKeys: keysStated(figure) ? notationOfKeys(figure) : void 0, keys: figure };
 }
-function conditionUnit(condition2, field, fieldOf2) {
-  if (!comparesFigure(condition2.operator)) return { ok: true, unit: void 0 };
-  const stated = condition2.unit_option;
-  const read2 = figureRowSelect(field);
-  if (read2 === void 0) {
-    return stated === void 0 ? { ok: true, unit: void 0 } : { ok: false, reason: `${nameOf(field)} is read in one unit for every row, so a condition on it states no unit_option.` };
-  }
-  const select = fieldOf2(read2.key);
-  const options = effectiveSelectOptions(select) ?? [];
-  const held2 = options.length === 0 ? `${select === void 0 ? `"${read2.key}"` : nameOf(select)} holds no ${read2.vocabulary} yet` : `one of ${options.map((option2) => `${option2.name} (${option2.key})`).join(", ")}`;
-  const reads = `${nameOf(field)} is read in each row's own ${read2.vocabulary} (${select === void 0 ? `"${read2.key}"` : nameOf(select)})`;
-  if (stated === void 0) {
-    const unstated = condition2.value === null || condition2.value === void 0 || condition2.value === "";
-    return unstated ? { ok: true, unit: void 0 } : { ok: false, reason: `${reads}, so '${condition2.operator}' states the ${read2.vocabulary} its value is in as unit_option: ${held2}.` };
-  }
-  const option = typeof stated === "string" ? options.find((candidate) => candidate.key === stated) : void 0;
-  if (option === void 0) {
-    return { ok: false, reason: `${reads}; unit_option ${JSON.stringify(stated)} is none of them: ${held2}.` };
-  }
-  const target = read2.vocabulary === "unit" ? measuredUnit(option.name) : void 0;
-  if (target === void 0) return { ok: true, unit: { select: read2, options: [{ key: option.key, factor: 1 }], factor: 1 } };
-  const kin = options.flatMap((candidate) => {
-    const measured = measuredUnit(candidate.name);
-    return measured?.dimension === target.dimension ? [{ key: candidate.key, factor: measured.factor }] : [];
-  });
-  return { ok: true, unit: { select: read2, options: kin, factor: target.factor } };
+function sameReading(a, b) {
+  return a === "link" || b === "link" ? a === b : sameNotation(a, b);
 }
-function rowUnitFactor(unit, data) {
-  const key = firstOptionKey(data[unit.select.key]);
-  return key === void 0 ? void 0 : unit.options.find((option) => option.key === key)?.factor;
+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";
+  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`;
+}
+function checkedReading(reading, held2) {
+  const refused = changedCurrencyRefusal(reading, held2);
+  return refused === void 0 ? { reading } : { refusal: refused };
+}
+function changedCurrencyRefusal(reading, held2) {
+  const currency = reading === "link" || sameReading(reading, held2) ? void 0 : notationCurrency(reading);
+  return currency === void 0 ? void 0 : currencyCodeRefusal(currency);
 }
 
 // ../shared/src/icon_names.generated.ts
@@ -23625,7 +23864,11 @@ var KIT_GLYPH_NAMES = [
   "align-center",
   "align-left",
   "align-right",
+  "align-vertical-justify-center",
+  "align-vertical-justify-end",
+  "align-vertical-justify-start",
   "arrow-down",
+  "arrow-down-a-z",
   "arrow-down-up",
   "arrow-down-wide-narrow",
   "arrow-left",
@@ -23636,10 +23879,13 @@ var KIT_GLYPH_NAMES = [
   "arrow-up",
   "arrow-up-down",
   "arrow-up-wide-narrow",
+  "arrow-up-z-a",
   "ban",
   "banknote",
   "bed",
   "bell",
+  "between-horizontal-start",
+  "between-vertical-start",
   "bold",
   "bolt",
   "book-marked",
@@ -23667,17 +23913,23 @@ var KIT_GLYPH_NAMES = [
   "chevrons-up-down",
   "circle-alert",
   "circle-check",
+  "circle-x",
   "clipboard-list",
+  "clipboard-paste",
   "clock",
   "code",
   "code-xml",
   "columns-3",
   "columns-3-cog",
+  "combine",
   "construction",
   "container",
   "copy",
   "credit-card",
   "database",
+  "decimals-arrow-left",
+  "decimals-arrow-right",
+  "dollar-sign",
   "download",
   "ellipsis",
   "eraser",
@@ -23704,9 +23956,11 @@ var KIT_GLYPH_NAMES = [
   "gauge",
   "globe",
   "gpu",
+  "grid-2x2",
   "grip-vertical",
   "group",
   "hand-coins",
+  "hash",
   "heading",
   "heading-1",
   "heading-2",
@@ -23759,6 +24013,7 @@ var KIT_GLYPH_NAMES = [
   "notepad-text-dashed",
   "package",
   "paint-bucket",
+  "paintbrush-vertical",
   "palette",
   "panel-left",
   "panel-left-close",
@@ -23769,6 +24024,7 @@ var KIT_GLYPH_NAMES = [
   "paperclip",
   "pause",
   "pencil",
+  "percent",
   "phone",
   "pin",
   "pin-off",
@@ -23783,7 +24039,9 @@ var KIT_GLYPH_NAMES = [
   "repeat",
   "rotate-ccw",
   "rotate-cw",
+  "rows-3",
   "scan",
+  "scissors",
   "search",
   "send",
   "settings",
@@ -23793,9 +24051,11 @@ var KIT_GLYPH_NAMES = [
   "shield-alert",
   "shield-check",
   "shopping-cart",
+  "sigma",
   "sliders-horizontal",
   "smile",
   "smile-plus",
+  "snowflake",
   "sparkles",
   "split",
   "square",
@@ -23804,11 +24064,13 @@ var KIT_GLYPH_NAMES = [
   "square-sigma",
   "stethoscope",
   "sticky-note",
+  "strikethrough",
   "table",
   "table-2",
   "tag",
   "target",
   "text-quote",
+  "text-wrap",
   "thumbs-down",
   "thumbs-up",
   "ticket",
@@ -23819,6 +24081,7 @@ var KIT_GLYPH_NAMES = [
   "truck",
   "tv-minimal",
   "twitter",
+  "type",
   "underline",
   "undo",
   "upload",
@@ -23831,7 +24094,9 @@ var KIT_GLYPH_NAMES = [
   "workflow",
   "wrench",
   "x",
-  "zap"
+  "zap",
+  "zoom-in",
+  "zoom-out"
 ];
 
 // ../shared/src/icon_names.ts
@@ -23971,6 +24236,68 @@ function everyOptionMarked(nameOf2) {
   };
 }
 
+// ../shared/src/select_option_enrichment.ts
+function effectiveSelectOptions(field) {
+  if (field === void 0) return null;
+  if (field.type === "select") return field.options ?? null;
+  if (field.type === "formula") return field.formula?.options ?? null;
+  if (field.type === "lookup" && field.lookup_field_type === "select") {
+    return field.lookup_field_options ?? null;
+  }
+  return null;
+}
+
+// ../shared/src/row_figure.ts
+function figureRowSelect(field) {
+  return notationRowSelect(fieldNotation(field));
+}
+function firstOptionKey(cell) {
+  if (!Array.isArray(cell)) return void 0;
+  for (const entry of cell) {
+    if (typeof entry === "string") return entry;
+    const inner = firstOptionKey(entry);
+    if (inner !== void 0) return inner;
+  }
+  return void 0;
+}
+function comparesFigure(operator) {
+  return operator !== "is_empty" && operator !== "is_not_empty";
+}
+function nameOf(field) {
+  return `"${field.name ?? field.key}"`;
+}
+function conditionUnit(condition2, field, fieldOf2) {
+  if (!comparesFigure(condition2.operator)) return { ok: true, unit: void 0 };
+  const stated = condition2.unit_option;
+  const read2 = figureRowSelect(field);
+  if (read2 === void 0) {
+    return stated === void 0 ? { ok: true, unit: void 0 } : { ok: false, reason: `${nameOf(field)} is read in one unit for every row, so a condition on it states no unit_option.` };
+  }
+  const select = fieldOf2(read2.key);
+  const options = effectiveSelectOptions(select) ?? [];
+  const held2 = options.length === 0 ? `${select === void 0 ? `"${read2.key}"` : nameOf(select)} holds no ${read2.vocabulary} yet` : `one of ${options.map((option2) => `${option2.name} (${option2.key})`).join(", ")}`;
+  const reads = `${nameOf(field)} is read in each row's own ${read2.vocabulary} (${select === void 0 ? `"${read2.key}"` : nameOf(select)})`;
+  if (stated === void 0) {
+    const unstated = condition2.value === null || condition2.value === void 0 || condition2.value === "";
+    return unstated ? { ok: true, unit: void 0 } : { ok: false, reason: `${reads}, so '${condition2.operator}' states the ${read2.vocabulary} its value is in as unit_option: ${held2}.` };
+  }
+  const option = typeof stated === "string" ? options.find((candidate) => candidate.key === stated) : void 0;
+  if (option === void 0) {
+    return { ok: false, reason: `${reads}; unit_option ${JSON.stringify(stated)} is none of them: ${held2}.` };
+  }
+  const target = read2.vocabulary === "unit" ? measuredUnit(option.name) : void 0;
+  if (target === void 0) return { ok: true, unit: { select: read2, options: [{ key: option.key, factor: 1 }], factor: 1 } };
+  const kin = options.flatMap((candidate) => {
+    const measured = measuredUnit(candidate.name);
+    return measured?.dimension === target.dimension ? [{ key: candidate.key, factor: measured.factor }] : [];
+  });
+  return { ok: true, unit: { select: read2, options: kin, factor: target.factor } };
+}
+function rowUnitFactor(unit, data) {
+  const key = firstOptionKey(data[unit.select.key]);
+  return key === void 0 ? void 0 : unit.options.find((option) => option.key === key)?.factor;
+}
+
 // ../shared/src/diacritics.ts
 var COMBINING_MARKS = /[̀-ͯ]/g;
 function foldDiacritics(value) {
@@ -24564,22 +24891,35 @@ function perRowRefusals(value) {
     ...currencyField.map((message2) => ({ key: "currency_field", message: message2 }))
   ];
 }
+function figureKeysRefusals(value) {
+  const refused = numberUnitRefusal(value.format, value.unit);
+  return [...refused === void 0 ? [] : [{ key: "unit", message: refused }], ...perRowRefusals(value)];
+}
 function figureIssue(path) {
   return (value, ctx) => {
-    const refused = numberUnitRefusal(value.format, value.unit);
-    if (refused !== void 0) ctx.addIssue({ code: "custom", message: refused, path: [...path, "unit"] });
-    for (const { key, message: message2 } of perRowRefusals(value)) ctx.addIssue({ code: "custom", message: message2, path: [...path, key] });
+    for (const { key, message: message2 } of figureKeysRefusals(value)) ctx.addIssue({ code: "custom", message: message2, path: [...path, key] });
   };
 }
-var tableNumberFieldSchema = tableFieldBaseSchema.extend({
+var BEFORE_NOTATION = 'Before "notation", and read as it: state "notation" instead.';
+function notationStatedIssue(path) {
+  return (value, ctx) => {
+    if (value.notation === void 0) return;
+    const settled = settledReading(notationSaid(value), void 0);
+    if ("refusal" in settled) ctx.addIssue({ code: "custom", message: settled.refusal, path: [...path, "notation"] });
+  };
+}
+var tableNumberFieldShape = tableFieldBaseSchema.extend({
   type: zod_default.literal("number"),
-  format: numberFormatSchema,
-  currency: zod_default.string().nullish().describe("ISO 4217 code. null clears it."),
-  unit: zod_default.string().nullish().describe(`${UNIT_DESCRIPTION} null clears it.`),
-  unit_field: zod_default.string().nullish().describe(`${UNIT_FIELD_DESCRIPTION} null clears it.`),
-  currency_field: zod_default.string().nullish().describe(`${CURRENCY_FIELD_DESCRIPTION} null clears it.`),
+  notation: notationSchema.optional(),
+  format: numberFormatSchema.describe(BEFORE_NOTATION),
+  currency: zod_default.string().nullish().describe(`ISO 4217 code. null clears it. ${BEFORE_NOTATION}`),
+  unit: zod_default.string().nullish().describe(`${UNIT_DESCRIPTION} null clears it. ${BEFORE_NOTATION}`),
+  unit_field: zod_default.string().nullish().describe(`${UNIT_FIELD_DESCRIPTION} null clears it. ${BEFORE_NOTATION}`),
+  currency_field: zod_default.string().nullish().describe(`${CURRENCY_FIELD_DESCRIPTION} null clears it. ${BEFORE_NOTATION}`),
   default_value: numberDefaultValueSchema
-}).superRefine(figureIssue([]));
+});
+var tableNumberFieldSchema = tableNumberFieldShape.superRefine(figureIssue([]));
+var tableNumberFieldInputSchema = tableNumberFieldShape.extend({ format: numberFormatSchema.optional().describe(BEFORE_NOTATION) }).superRefine(figureIssue([]));
 var tableTextFieldSchema = tableFieldBaseSchema.extend({
   type: zod_default.literal("text"),
   unique: zod_default.boolean().optional().describe("Unique values required"),
@@ -24672,6 +25012,9 @@ var tableRollupFieldSchema = tableFieldBaseSchema.extend({
   aggregate_field_type: tableFieldTypeNameSchema.optional().describe(
     "What this rollup's CELL holds \u2014 'date' for earliest/latest, 'number' for every other operation (counts, sums, percentages). Derived from the operation, not from the aggregated field: a 'filled' count over a files column is a number. Server-derived at write time; ignored on input."
   ),
+  aggregate_field_notation: notationSchema.optional().describe(
+    `How this rollup's figure reads. Operations that preserve the aggregated value's unit (sum/avg/median/min/max/range) inherit the target field's; counts are a decimal, percentages the unit "percent". Server-derived at write time; ignored on input.`
+  ),
   aggregate_field_format: zod_default.string().optional().describe(
     "The format of this rollup's own value. Operations that preserve the aggregated value's unit (sum/avg/median/min/max/range/earliest/latest) inherit the target field's format; counting operations are 'number', percentages 'percentage'. Server-derived at write time; ignored on input."
   ),
@@ -24699,6 +25042,9 @@ var tableLookupFieldSchema = tableFieldBaseSchema.extend({
   lookup_field_type: tableFieldTypeNameSchema.optional().describe(
     "The type of the target lookup field (e.g. 'text', 'number', 'date'). Resolved from the linked table's field definition at read time."
   ),
+  lookup_field_notation: notationSchema.optional().describe(
+    "How the looked-up figure reads, where the target lookup field holds a number. Resolved from the linked table's field definition at write time."
+  ),
   lookup_field_format: zod_default.string().optional().describe(
     "The format of the target lookup field (e.g. 'currency', 'percentage', 'datetime'). Resolved from the linked table's field definition at read time."
   ),
@@ -24711,6 +25057,9 @@ var tableLookupFieldSchema = tableFieldBaseSchema.extend({
   lookup_field_options: zod_default.array(zod_default.object({ key: zod_default.string(), name: zod_default.string(), color: zod_default.string().optional(), mark: storedOptionMarkSchema.optional() })).optional().describe(
     "Options for select-type lookup fields. Synced from the source select field's options."
   ),
+  lookup_field_autonumber: zod_default.boolean().optional().describe(
+    "True where the looked-up value is an autonumber's text, which sorts by its number where it is a bare one. Synced from the looked-up field."
+  ),
   order_by: lookupOrderBySchema.optional().describe(
     "When set, sort the linked records by this field on the linked table and return ONLY the picked field from the single extreme record (desc=latest, asc=earliest), as a one-element array. Omit to return every linked record's value as an array. field_key must be a field on the linked table."
   )
@@ -24723,25 +25072,36 @@ var formulaInputSchema = zod_default.object({
   expression: zod_default.string().describe(
     "JavaScript expression. Uses {Field Name} for field references."
   ),
-  format: zod_default.enum(["number", "currency", "percentage", "link"]).optional().describe(
-    "Display format. 'number' / 'currency' / 'percentage' for numeric results; 'link' for text-output formulas that return a URL \u2014 renders the result as a clickable link."
-  ),
-  currency: zod_default.string().optional().describe("ISO 4217 currency code, e.g. USD, VND, EUR"),
-  unit: zod_default.string().optional().describe(UNIT_DESCRIPTION),
-  unit_field: zod_default.string().optional().describe(UNIT_FIELD_DESCRIPTION),
-  currency_field: zod_default.string().optional().describe(CURRENCY_FIELD_DESCRIPTION),
+  notation: notationSchema.optional().describe(`${NOTATION_DESCRIPTION} For a formula yielding a number.`),
+  link: zod_default.literal(true).optional().describe("The formula yields a URL as text, drawn as a link that opens."),
+  format: zod_default.enum(["number", "currency", "percentage", "link"]).optional().describe(`'number' / 'currency' / 'percentage' for numeric results; 'link' for a URL. ${BEFORE_NOTATION} 'link' is "link": true.`),
+  currency: zod_default.string().optional().describe(`ISO 4217 currency code, e.g. USD, VND, EUR. ${BEFORE_NOTATION}`),
+  unit: zod_default.string().optional().describe(`${UNIT_DESCRIPTION} ${BEFORE_NOTATION}`),
+  unit_field: zod_default.string().optional().describe(`${UNIT_FIELD_DESCRIPTION} ${BEFORE_NOTATION}`),
+  currency_field: zod_default.string().optional().describe(`${CURRENCY_FIELD_DESCRIPTION} ${BEFORE_NOTATION}`),
   options: zod_default.array(tableSelectFieldOptionSchema).min(1).optional().describe(
     "The categories the formula yields, drawn as a single select's options are. The expression yields one option's `key` (text) or null; a key it does not declare computes an error. Omit for a formula yielding a plain value."
   )
 });
+var formulaToolInputSchema = formulaInputSchema.omit({ format: true, currency: true, unit: true, unit_field: true, currency_field: true });
 var formulaSchema = formulaInputSchema.extend({
   output_type: formulaOutputTypeSchema.optional().describe("Output type of the formula. Inferred by the backend from the expression \u2014 read-only on input. `datetime` when the result carries a time of day (references a datetime field or a time-bearing helper); `select` when the formula declares `options`."),
   volatile: zod_default.boolean().optional().describe("Whether the formula's result depends on `now()` or other non-deterministic helpers. Inferred by the backend \u2014 read-only on input.")
 });
-var tableFormulaFieldSchema = tableFieldBaseSchema.extend({
+var tableFormulaFieldShape = tableFieldBaseSchema.extend({
   type: zod_default.literal("formula").describe("Field type for calculated values based on expressions"),
   formula: formulaSchema.describe("Formula configuration and expression")
-}).superRefine((field, ctx) => figureIssue(["formula"])(field.formula, ctx));
+});
+var tableFormulaFieldSchema = tableFormulaFieldShape.superRefine((field, ctx) => figureIssue(["formula"])(field.formula, ctx));
+function formulaLinks(formula) {
+  return formula.format == null ? formula.link === true : formula.format === "link";
+}
+function formulaLinkIssue(formula, ctx) {
+  if (formula.link === true && formula.notation !== void 0) {
+    ctx.addIssue({ code: "custom", message: "a formula yielding a link yields text, which reads in no notation", path: ["formula", "link"] });
+  }
+}
+var tableFormulaFieldInputSchema = tableFormulaFieldShape.superRefine((field, ctx) => figureIssue(["formula"])(field.formula, ctx)).superRefine((field, ctx) => formulaLinkIssue(field.formula, ctx));
 var workflowMetadataSchema = zod_default.object({
   table_ids: zod_default.array(zod_default.string()).describe("IDs of the tables this workflow affects"),
   staged_for_app_id: zod_default.string().optional().describe(
@@ -24797,7 +25157,7 @@ var tableFieldSchema = zod_default.discriminatedUnion("type", [
   tableAutonumberFieldSchema
 ]);
 var tableFieldInputSchema = zod_default.discriminatedUnion("type", [
-  tableNumberFieldSchema,
+  tableNumberFieldInputSchema,
   tableTextFieldSchema,
   tableDateFieldSchema,
   tableBooleanFieldSchema,
@@ -24807,16 +25167,28 @@ var tableFieldInputSchema = zod_default.discriminatedUnion("type", [
   tableRollupFieldSchema,
   tableLookupFieldSchema,
   tableFilesFieldSchema,
-  tableFormulaFieldSchema,
+  tableFormulaFieldInputSchema,
   tableButtonFieldSchema,
   tableAutonumberFieldSchema
 ]);
 var tableFieldsSchema = zod_default.array(tableFieldSchema);
-function selectOptionsOf(field) {
-  if (field.type === "select") return field.options;
-  if (field.type === "formula") return field.formula.options;
-  return void 0;
-}
+var tableFieldsInputSchema = zod_default.array(
+  zod_default.discriminatedUnion("type", [
+    tableNumberFieldInputSchema,
+    tableTextFieldSchema,
+    tableDateFieldSchema,
+    tableBooleanFieldSchema,
+    tableSelectFieldSchema,
+    tableSelectMemberFieldSchema,
+    tableSelectRecordLinkFieldSchema,
+    tableRollupFieldSchema,
+    tableLookupFieldSchema,
+    tableFilesFieldSchema,
+    tableFormulaFieldInputSchema,
+    tableButtonFieldSchema,
+    tableAutonumberFieldSchema
+  ])
+);
 var tableFieldCreateBaseSchema = zod_default.object({
   name: zod_default.string().describe("Display name"),
   description: zod_default.string().describe("Field description"),
@@ -24830,13 +25202,9 @@ var tableSelectFieldOptionCreateSchema = zod_default.object({
 var tableFieldTypeConfigSchema = zod_default.discriminatedUnion("type", [
   zod_default.object({
     type: zod_default.literal("number"),
-    format: numberFormatSchema.default("number"),
-    currency: zod_default.string().optional().describe("ISO 4217 code"),
-    unit: zod_default.string().optional().describe(UNIT_DESCRIPTION),
-    unit_field: zod_default.string().optional().describe(UNIT_FIELD_DESCRIPTION),
-    currency_field: zod_default.string().optional().describe(CURRENCY_FIELD_DESCRIPTION),
+    notation: notationSchema.optional().describe(`${NOTATION_DESCRIPTION} Omitted, a decimal.`),
     default_value: numberDefaultValueSchema
-  }).superRefine(figureIssue([])),
+  }).superRefine(notationStatedIssue([])),
   zod_default.object({
     type: zod_default.literal("text"),
     unique: zod_default.boolean().optional().describe("Unique values required"),
@@ -24900,8 +25268,8 @@ var tableFieldTypeConfigSchema = zod_default.discriminatedUnion("type", [
   }),
   zod_default.object({
     type: zod_default.literal("formula"),
-    formula: formulaInputSchema
-  }).superRefine((field, ctx) => figureIssue(["formula"])(field.formula, ctx)),
+    formula: formulaToolInputSchema
+  }).superRefine((field, ctx) => notationStatedIssue(["formula"])(field.formula, ctx)).superRefine((field, ctx) => formulaLinkIssue(field.formula, ctx)),
   // `button` is deliberately absent: button fields are legacy — this union
   // shapes CREATE input only, and new buttons can no longer be created
   // (see LEGACY_FIELD_TYPES). Stored button fields still parse via the
@@ -24972,10 +25340,8 @@ function projectCell(field, value) {
   }
 }
 
-// ../shared/src/walk_workflow_expression.ts
-var LINKED_CALL = "linked";
-var GRAMMAR_NAME_SHAPE = `${LINKED_CALL}(record["fld_link"])[0] fetches one linked row`;
-var RUNTIME_KEYS = /* @__PURE__ */ new Set([
+// ../shared/src/schemas/workflow_expressions.ts
+var runtimeKeySchema = zod_default.enum([
   "timezone",
   "workflow_id",
   "execution_id",
@@ -24983,184 +25349,10 @@ var RUNTIME_KEYS = /* @__PURE__ */ new Set([
   "organization_id",
   "now",
   "change_origin",
-  "execution_principal",
   "triggered_by_member_id"
 ]);
-var CURRENT_MEMBER_IN_ANY_GROUP = "current_member_in_any_group";
-var PARKED_RUNTIME_KEYS = /* @__PURE__ */ new Map([
-  [
-    "execution_principal",
-    `runtime.execution_principal is not readable \u2014 a workflow runs under the OWNER's authority, so it never answers "is the person who triggered this allowed?". Authorize the caller with ${CURRENT_MEMBER_IN_ANY_GROUP}(["grp_\u2026"]) or read runtime.triggered_by_member_id.`
-  ]
-]);
-var READABLE_RUNTIME_KEYS = Array.from(RUNTIME_KEYS).filter(
-  (key) => !PARKED_RUNTIME_KEYS.has(key)
-);
-var INLINE_HELPERS = [
-  "formatCurrency",
-  "randomNumber",
-  "randomAlphaNumeric",
-  "sample",
-  // Actor authorization predicate — resolves the triggering member's groups
-  // server-side (bound in the backend helper registry, not a pure shared
-  // helper).
-  CURRENT_MEMBER_IN_ANY_GROUP
-];
-var HELPERS = /* @__PURE__ */ new Set([
-  ...Object.keys(expression_array_exports),
-  ...Object.keys(expression_string_exports),
-  ...Object.keys(expression_math_exports),
-  ...Object.keys(expression_object_exports),
-  ...Object.keys(expression_type_exports),
-  ...Object.keys(getDateExpressionFunctions()),
-  ...INLINE_HELPERS
-]);
-function isHelper(name) {
-  return HELPERS.has(name);
-}
-var HELPER_MENU = [
-  `text \u2014 ${Object.keys(expression_string_exports).sort().join(", ")}`,
-  `number \u2014 ${Object.keys(expression_math_exports).sort().join(", ")}`,
-  `array \u2014 ${Object.keys(expression_array_exports).sort().join(", ")}`,
-  `object \u2014 ${Object.keys(expression_object_exports).sort().join(", ")}`,
-  `type/null \u2014 ${Object.keys(expression_type_exports).sort().join(", ")}`,
-  `date \u2014 ${Object.keys(getDateExpressionFunctions()).sort().join(", ")}`,
-  `other \u2014 ${[...INLINE_HELPERS].sort().join(", ")}`
-].join("; ");
-var AWAIT_IF_FORM = "Write the if form: let x = null; if (<condition>) { x = await tool({...}); }";
-var AWAIT_IN_OPTIONAL_CHAIN = `An await after \`?.\` runs only when the value before it is not null. ${AWAIT_IF_FORM}`;
-var CALLBACK_HELPERS = /* @__PURE__ */ new Set([
-  "filter",
-  "find",
-  "pluck",
-  "sortBy",
-  "sumBy",
-  "meanBy",
-  "minBy",
-  "maxBy",
-  "countBy",
-  "groupBy",
-  "uniqueBy",
-  "some",
-  "every",
-  "differenceBy",
-  "intersectionBy",
-  "reduce"
-]);
-var LAMBDA_POSITION_HINT = `Function expressions are not supported here. A lambda \u2014 either \`(x) => <expr>\` or \`function (x) { return <expr>; }\` \u2014 is legal only INLINE as a callback argument to ${[...CALLBACK_HELPERS].sort().join(" / ")}, e.g. pluck(rows, (r) => r.qty * r.price). To NAME reusable logic, declare it at the top level instead: \`function toLine(l = {}) { return { ... }; }\` \u2014 every parameter needs a default, and the body is inlined at each call site. Binding a lambda to a name (const f = (x) => ...) or calling one directly stays unsupported.`;
-var HELPER_ALIASES = /* @__PURE__ */ new Map([
-  ["String", "toString"],
-  ["Number", "toNumber"],
-  ["parseFloat", "toNumber"],
-  // faithful: toNumber IS parseFloat semantics
-  ["toUpperCase", "upper"],
-  ["toLowerCase", "lower"],
-  ["map", "pluck"],
-  // arr.map(x => …) ≡ pluck(arr, x => …)
-  ["toFixed", "formatNumber"]
-  // x.toFixed(2) ≡ formatNumber(x, 2)
-]);
-var REJECTED_HELPERS = /* @__PURE__ */ new Map([
-  [
-    "parseInt",
-    {
-      message: "parseInt is not supported \u2014 parse with toNumber(x), then apply floor(...), ceil(...), or round(...) to get a whole number. floor rounds down (toward negative infinity), so for negative values choose the rounding deliberately.",
-      construct: "parse_int"
-    }
-  ]
-]);
-var NAMESPACE_HELPERS = /* @__PURE__ */ new Map([
-  ["JSON", /* @__PURE__ */ new Map([["parse", "parseJson"], ["stringify", "toJson"]])],
-  ["Array", /* @__PURE__ */ new Map([["isArray", "isArray"]])],
-  ["Object", /* @__PURE__ */ new Map([["keys", "keys"], ["values", "values"], ["entries", "entries"]])],
-  ["Number", /* @__PURE__ */ new Map([["parseFloat", "toNumber"]])]
-]);
-var METHOD_FORM_NAMES = /* @__PURE__ */ new Set([
-  // String.prototype
-  "trim",
-  "toUpperCase",
-  "toLowerCase",
-  "replace",
-  "replaceAll",
-  "split",
-  "substring",
-  "padStart",
-  "padEnd",
-  "startsWith",
-  "endsWith",
-  // String.prototype + Array.prototype
-  "includes",
-  "slice",
-  "at",
-  "concat",
-  // Array.prototype
-  "join",
-  "reverse",
-  "map",
-  "filter",
-  "find",
-  "some",
-  "every",
-  "reduce",
-  // Number.prototype / Object.prototype
-  "toFixed",
-  "toString"
-]);
-var METHOD_FORM_MENU = [...METHOD_FORM_NAMES].sort().join(", ");
-var PROPERTY_HELPERS = /* @__PURE__ */ new Map([["length", "length"]]);
-var HELPER_SPELLINGS = (() => {
-  const out = /* @__PURE__ */ new Map();
-  const add = (helper, spelling) => {
-    if (isHelper(helper) && !out.has(helper)) out.set(helper, spelling);
-  };
-  for (const name of METHOD_FORM_NAMES) add(HELPER_ALIASES.get(name) ?? name, { kind: "method", name });
-  for (const [name, helper] of PROPERTY_HELPERS) add(helper, { kind: "property", name });
-  for (const [namespace, members2] of NAMESPACE_HELPERS) {
-    for (const [member, helper] of members2) add(helper, { kind: "namespace", namespace, member });
-  }
-  for (const fn of Object.keys(expression_math_exports)) {
-    if (fn !== "random" && typeof Reflect.get(Math, fn) === "function") {
-      add(fn, { kind: "namespace", namespace: "Math", member: fn });
-    }
-  }
-  return out;
-})();
-var RESERVED_CALLABLE_NAMES = /* @__PURE__ */ new Set([
-  ...REJECTED_HELPERS.keys(),
-  ...NAMESPACE_HELPERS.keys(),
-  "Math",
-  "Boolean"
-]);
-var LINKED_ARITY = `${LINKED_CALL}(...) takes exactly one argument \u2014 the read of the link field, e.g. ${LINKED_CALL}(record["fld_link"])[0] for one row or ${LINKED_CALL}(record["fld_link"]) for every row.`;
-var LINKED_ARGUMENT_SHAPE = `The argument of ${LINKED_CALL}(...) must END on the link field, because that field is what it follows \u2014 ${LINKED_CALL}(record["fld_link"])[0]. A value that names no field (a binding, a literal, a helper result) cannot say which link to follow; read the field on it: ${LINKED_CALL}(ids["fld_link"]).`;
-var LINKED_OPTIONAL_RESULT = `${LINKED_CALL}(...) always returns an array, never null, so \`?.\` on its result can never fire. The argument takes a guard \u2014 ${LINKED_CALL}(record?.["fld_link"])[0] \u2014 and so does the fetched row, which is null where the linked record is deleted or unreadable: ${LINKED_CALL}(record["fld_link"])[0]?.["fld_x"].`;
-var LINKED_METHOD_FORM = `${LINKED_CALL} has no method form \u2014 write ${LINKED_CALL}(record["fld_link"])[0], with the link read as the argument.`;
-var LINKED_ON_NON_RECORD = `${LINKED_CALL}(...) follows a link field on a record, and this value is not one. Read the record first, then follow the link: ${LINKED_CALL}(record["fld_link"])[0].`;
-var LINKED_ON_CHANGES = `A change diff is not a record, so ${LINKED_CALL}(...) cannot follow a link off it. Read the post-state with ${LINKED_CALL}(record["fld_link"]) or the pre-state with ${LINKED_CALL}(prev_record["fld_link"]).`;
-var READ_ROOT_HINT = `A read starts from a name: a reserved identifier (record, prev_record, changes, runtime, trigger, index), a binding, or ${LINKED_CALL}(record["fld_link"]). Bind the value first \u2014 const x = <expression>; \u2014 then read x.y.`;
-
-// ../shared/src/schemas/workflow_expressions.ts
-var runtimeKeySchema = zod_default.enum([
-  "timezone",
-  "workflow_id",
-  "execution_id",
-  "workspace_id",
-  "organization_id",
-  "now",
-  "change_origin",
-  // PARKED — accepted in stored ASTs, rejected for new saves at parse (see
-  // `PARKED_RUNTIME_KEYS` in walk_workflow_expression.ts). It is the OWNER's
-  // principal (a workflow runs under owner authority), so it can't answer the
-  // caller-authorization question anyone reads it for; the generated `.d.ts`
-  // omits it and the docs point at `current_member_in_any_group` /
-  // `runtime.triggered_by_member_id` instead. The entry stays so any stored
-  // AST keeps validating and executing — drop it only once a prod probe shows
-  // zero references (`workflows.steps_v2::text LIKE '%execution_principal%'`).
-  "execution_principal",
-  "triggered_by_member_id"
-]);
-var nestedExpressionSchema = zod_default.lazy(
-  () => workflowExpressionSchema
+var nestedExpressionSchema = zod_default.lazy(
+  () => workflowExpressionSchema
 );
 var readSourceSchema = zod_default.discriminatedUnion("from", [
   zod_default.object({ from: zod_default.literal("trigger") }),
@@ -25329,6 +25521,154 @@ var templatePartSchema = zod_default.lazy(
   ])
 );
 
+// ../shared/src/walk_workflow_expression.ts
+var LINKED_CALL = "linked";
+var GRAMMAR_NAME_SHAPE = `${LINKED_CALL}(record["fld_link"])[0] fetches one linked row`;
+var RUNTIME_KEYS = new Set(runtimeKeySchema.options);
+var CURRENT_MEMBER_IN_ANY_GROUP = "current_member_in_any_group";
+var INLINE_HELPERS = [
+  "formatCurrency",
+  "randomNumber",
+  "randomAlphaNumeric",
+  "sample",
+  // Actor authorization predicate — resolves the triggering member's groups
+  // server-side (bound in the backend helper registry, not a pure shared
+  // helper).
+  CURRENT_MEMBER_IN_ANY_GROUP
+];
+var HELPERS = /* @__PURE__ */ new Set([
+  ...Object.keys(expression_array_exports),
+  ...Object.keys(expression_string_exports),
+  ...Object.keys(expression_math_exports),
+  ...Object.keys(expression_object_exports),
+  ...Object.keys(expression_type_exports),
+  ...Object.keys(getDateExpressionFunctions()),
+  ...INLINE_HELPERS
+]);
+function isHelper(name) {
+  return HELPERS.has(name);
+}
+var HELPER_MENU = [
+  `text \u2014 ${Object.keys(expression_string_exports).sort().join(", ")}`,
+  `number \u2014 ${Object.keys(expression_math_exports).sort().join(", ")}`,
+  `array \u2014 ${Object.keys(expression_array_exports).sort().join(", ")}`,
+  `object \u2014 ${Object.keys(expression_object_exports).sort().join(", ")}`,
+  `type/null \u2014 ${Object.keys(expression_type_exports).sort().join(", ")}`,
+  `date \u2014 ${Object.keys(getDateExpressionFunctions()).sort().join(", ")}`,
+  `other \u2014 ${[...INLINE_HELPERS].sort().join(", ")}`
+].join("; ");
+var AWAIT_IF_FORM = "Write the if form: let x = null; if (<condition>) { x = await tool({...}); }";
+var AWAIT_IN_OPTIONAL_CHAIN = `An await after \`?.\` runs only when the value before it is not null. ${AWAIT_IF_FORM}`;
+var CALLBACK_HELPERS = /* @__PURE__ */ new Set([
+  "filter",
+  "find",
+  "pluck",
+  "sortBy",
+  "sumBy",
+  "meanBy",
+  "minBy",
+  "maxBy",
+  "countBy",
+  "groupBy",
+  "uniqueBy",
+  "some",
+  "every",
+  "differenceBy",
+  "intersectionBy",
+  "reduce"
+]);
+var LAMBDA_POSITION_HINT = `Function expressions are not supported here. A lambda \u2014 either \`(x) => <expr>\` or \`function (x) { return <expr>; }\` \u2014 is legal only INLINE as a callback argument to ${[...CALLBACK_HELPERS].sort().join(" / ")}, e.g. pluck(rows, (r) => r.qty * r.price). To NAME reusable logic, declare it at the top level instead: \`function toLine(l = {}) { return { ... }; }\` \u2014 every parameter needs a default, and the body is inlined at each call site. Binding a lambda to a name (const f = (x) => ...) or calling one directly stays unsupported.`;
+var HELPER_ALIASES = /* @__PURE__ */ new Map([
+  ["String", "toString"],
+  ["Number", "toNumber"],
+  ["parseFloat", "toNumber"],
+  // faithful: toNumber IS parseFloat semantics
+  ["toUpperCase", "upper"],
+  ["toLowerCase", "lower"],
+  ["map", "pluck"],
+  // arr.map(x => …) ≡ pluck(arr, x => …)
+  ["toFixed", "formatNumber"]
+  // x.toFixed(2) ≡ formatNumber(x, 2)
+]);
+var REJECTED_HELPERS = /* @__PURE__ */ new Map([
+  [
+    "parseInt",
+    {
+      message: "parseInt is not supported \u2014 parse with toNumber(x), then apply floor(...), ceil(...), or round(...) to get a whole number. floor rounds down (toward negative infinity), so for negative values choose the rounding deliberately.",
+      construct: "parse_int"
+    }
+  ]
+]);
+var NAMESPACE_HELPERS = /* @__PURE__ */ new Map([
+  ["JSON", /* @__PURE__ */ new Map([["parse", "parseJson"], ["stringify", "toJson"]])],
+  ["Array", /* @__PURE__ */ new Map([["isArray", "isArray"]])],
+  ["Object", /* @__PURE__ */ new Map([["keys", "keys"], ["values", "values"], ["entries", "entries"]])],
+  ["Number", /* @__PURE__ */ new Map([["parseFloat", "toNumber"]])]
+]);
+var METHOD_FORM_NAMES = /* @__PURE__ */ new Set([
+  // String.prototype
+  "trim",
+  "toUpperCase",
+  "toLowerCase",
+  "replace",
+  "replaceAll",
+  "split",
+  "substring",
+  "padStart",
+  "padEnd",
+  "startsWith",
+  "endsWith",
+  // String.prototype + Array.prototype
+  "includes",
+  "slice",
+  "at",
+  "concat",
+  // Array.prototype
+  "join",
+  "reverse",
+  "map",
+  "filter",
+  "find",
+  "some",
+  "every",
+  "reduce",
+  // Number.prototype / Object.prototype
+  "toFixed",
+  "toString"
+]);
+var METHOD_FORM_MENU = [...METHOD_FORM_NAMES].sort().join(", ");
+var PROPERTY_HELPERS = /* @__PURE__ */ new Map([["length", "length"]]);
+var HELPER_SPELLINGS = (() => {
+  const out = /* @__PURE__ */ new Map();
+  const add = (helper, spelling) => {
+    if (isHelper(helper) && !out.has(helper)) out.set(helper, spelling);
+  };
+  for (const name of METHOD_FORM_NAMES) add(HELPER_ALIASES.get(name) ?? name, { kind: "method", name });
+  for (const [name, helper] of PROPERTY_HELPERS) add(helper, { kind: "property", name });
+  for (const [namespace, members2] of NAMESPACE_HELPERS) {
+    for (const [member, helper] of members2) add(helper, { kind: "namespace", namespace, member });
+  }
+  for (const fn of Object.keys(expression_math_exports)) {
+    if (fn !== "random" && typeof Reflect.get(Math, fn) === "function") {
+      add(fn, { kind: "namespace", namespace: "Math", member: fn });
+    }
+  }
+  return out;
+})();
+var RESERVED_CALLABLE_NAMES = /* @__PURE__ */ new Set([
+  ...REJECTED_HELPERS.keys(),
+  ...NAMESPACE_HELPERS.keys(),
+  "Math",
+  "Boolean"
+]);
+var LINKED_ARITY = `${LINKED_CALL}(...) takes exactly one argument \u2014 the read of the link field, e.g. ${LINKED_CALL}(record["fld_link"])[0] for one row or ${LINKED_CALL}(record["fld_link"]) for every row.`;
+var LINKED_ARGUMENT_SHAPE = `The argument of ${LINKED_CALL}(...) must END on the link field, because that field is what it follows \u2014 ${LINKED_CALL}(record["fld_link"])[0]. A value that names no field (a binding, a literal, a helper result) cannot say which link to follow; read the field on it: ${LINKED_CALL}(ids["fld_link"]).`;
+var LINKED_OPTIONAL_RESULT = `${LINKED_CALL}(...) always returns an array, never null, so \`?.\` on its result can never fire. The argument takes a guard \u2014 ${LINKED_CALL}(record?.["fld_link"])[0] \u2014 and so does the fetched row, which is null where the linked record is deleted or unreadable: ${LINKED_CALL}(record["fld_link"])[0]?.["fld_x"].`;
+var LINKED_METHOD_FORM = `${LINKED_CALL} has no method form \u2014 write ${LINKED_CALL}(record["fld_link"])[0], with the link read as the argument.`;
+var LINKED_ON_NON_RECORD = `${LINKED_CALL}(...) follows a link field on a record, and this value is not one. Read the record first, then follow the link: ${LINKED_CALL}(record["fld_link"])[0].`;
+var LINKED_ON_CHANGES = `A change diff is not a record, so ${LINKED_CALL}(...) cannot follow a link off it. Read the post-state with ${LINKED_CALL}(record["fld_link"]) or the pre-state with ${LINKED_CALL}(prev_record["fld_link"]).`;
+var READ_ROOT_HINT = `A read starts from a name: a reserved identifier (record, prev_record, changes, runtime, trigger, index), a binding, or ${LINKED_CALL}(record["fld_link"]). Bind the value first \u2014 const x = <expression>; \u2014 then read x.y.`;
+
 // ../shared/src/chat_models.ts
 var MODEL_TIERS = ["haiku", "sonnet", "opus"];
 var TIER_MODELS = {
@@ -26976,36 +27316,46 @@ var WorkflowEvalError = class extends Error {
   detail;
 };
 var WorkflowTimeBudgetError = class extends Error {
-  constructor(subject, budgetMs) {
-    super(`${subject} exceeded its time budget of ${budgetMs / 1e3}s.`);
+  /** `waitedFor`: what the run's deadline passed waiting on, when that was not the run's own work. */
+  constructor(subject, budgetMs, waitedFor) {
+    super(`${subject} exceeded its time budget of ${budgetMs / 1e3}s${waitedFor === void 0 ? "" : ` waiting for ${waitedFor}`}.`);
     this.name = "WorkflowTimeBudgetError";
   }
 };
 var WorkflowExpressionBudgetError = class extends Error {
-  constructor(exceeded) {
-    super(
-      exceeded === "nodes" ? `Expression evaluated more than ${MAX_EVALUATION_NODES} nodes. A callback nested in another runs once per pair of elements.` : `The run built more than ${MAX_RUN_BUILT_BYTES / 1024 / 1024}MB of arrays, objects and text. Build long text with join() rather than a fold of +.`
-    );
-    this.exceeded = exceeded;
+  constructor(budget) {
+    super(budgetMessage(budget));
+    this.budget = budget;
     this.name = "WorkflowExpressionBudgetError";
   }
-  exceeded;
+  budget;
 };
-var MAX_EVALUATION_NODES = 2e7;
+function budgetMessage(budget) {
+  switch (budget.exceeded) {
+    case "bytes":
+      return `The run built more than ${MAX_RUN_BUILT_BYTES / 1024 / 1024}MB of arrays, objects and text.`;
+    case "heap":
+      return `The expression used more than ${budget.heap_mb}MB of memory.`;
+    case "compute":
+      return `The expression computed for more than ${budget.compute_ms / 1e3}s.`;
+  }
+}
 var SLOT_BYTES = 8;
 var CHAR_BYTES = 2;
+var OBJECT_BYTES = 56;
 var EVALUATION_SLICE_MS = 20;
 var turn = {
   slice_started_ms: performance.now(),
   pause: null
 };
-function startRunBudget(subject, budgetMs) {
-  return { deadline_ms: Date.now() + budgetMs, budget_ms: budgetMs, subject, built_bytes: 0 };
+function startRunBudget(subject, budgetMs, path) {
+  return { host: "shared", deadline_ms: Date.now() + budgetMs, budget_ms: budgetMs, subject, path, built_bytes: 0 };
 }
 function runClock(run2) {
   if (Date.now() > run2.deadline_ms) {
     throw new WorkflowTimeBudgetError(run2.subject, run2.budget_ms);
   }
+  if (run2.host === "isolated") return null;
   if (turn.pause === null && performance.now() - turn.slice_started_ms >= EVALUATION_SLICE_MS) {
     turn.pause = new Promise((resolve) => setTimeout(resolve, 0)).then(() => {
       turn.pause = null;
@@ -27015,15 +27365,16 @@ function runClock(run2) {
   return turn.pause;
 }
 function chargeBuilt(run2, bytes) {
+  if (run2.host === "isolated") return;
   run2.built_bytes += bytes;
   if (run2.built_bytes > MAX_RUN_BUILT_BYTES) {
-    throw new WorkflowExpressionBudgetError("bytes");
+    throw new WorkflowExpressionBudgetError({ exceeded: "bytes" });
   }
 }
 function builtSize(value) {
   if (typeof value === "string") return value.length * CHAR_BYTES;
-  if (Array.isArray(value)) return value.length * SLOT_BYTES;
-  if (typeof value === "object" && value !== null) return Object.keys(value).length * SLOT_BYTES;
+  if (Array.isArray(value)) return OBJECT_BYTES + value.length * SLOT_BYTES;
+  if (typeof value === "object" && value !== null) return OBJECT_BYTES + Object.keys(value).length * SLOT_BYTES;
   return 0;
 }
 var PARSED_NODE_BYTES = 40;
@@ -27053,13 +27404,13 @@ function callbackWorkers() {
   };
 }
 function evaluateWorkflowExpression(expr2, ctx) {
-  const budget = { nodes: 0, workers: callbackWorkers(), settled: false };
+  const budget = { workers: callbackWorkers(), settled: false };
   return evaluateExpression(expr2, { ...ctx, evaluation_budget: budget }).finally(() => {
     budget.settled = true;
   });
 }
 async function evaluateExpression(expr2, ctx) {
-  for (let pause = spendNode(ctx); pause !== null; pause = checkClock(ctx)) await pause;
+  for (let pause = checkClock(ctx); pause !== null; pause = checkClock(ctx)) await pause;
   switch (expr2.kind) {
     case "lit":
       return expr2.value;
@@ -27096,15 +27447,6 @@ async function evaluateExpression(expr2, ctx) {
       return assertNever(expr2);
   }
 }
-function spendNode(ctx) {
-  const budget = ctx.evaluation_budget;
-  assertUnsettled(budget);
-  budget.nodes += 1;
-  if (budget.nodes > MAX_EVALUATION_NODES) {
-    throw new WorkflowExpressionBudgetError("nodes");
-  }
-  return runClock(ctx.run_budget);
-}
 function checkClock(ctx) {
   assertUnsettled(ctx.evaluation_budget);
   return runClock(ctx.run_budget);
@@ -28096,9 +28438,6 @@ function clientRuntime(input) {
     },
     get change_origin() {
       return unread("change_origin");
-    },
-    get execution_principal() {
-      return unread("execution_principal");
     }
   };
 }
@@ -28131,7 +28470,7 @@ async function predictWorkflowEffects(input) {
     trigger_table: null,
     member_lookup: async () => unread("member display"),
     lexical_bindings: [{}],
-    run_budget: startRunBudget("Write prediction", PREDICTION_BUDGET_MS)
+    run_budget: startRunBudget("Write prediction", PREDICTION_BUDGET_MS, "write")
   };
   const walk = { ctx, effects: [], written, input, unsure: false, aligned: true };
   try {
@@ -28144,6 +28483,9 @@ async function predictWorkflowEffects(input) {
 }
 
 // ../shared/src/lookup_display.ts
+function flattenLookupValues(values2) {
+  return values2.flatMap((value) => Array.isArray(value) ? flattenLookupValues(value) : [value]);
+}
 function lookupElementToString(element) {
   if (element === null || element === void 0) return "";
   if (typeof element === "boolean") return element ? "True" : "False";
@@ -29882,9 +30224,6 @@ function evaluateCondition(record2, fieldByKey, looseCondition, memberContext, f
   }
   return matchCell(columnValue, field, filterCondition, looseCondition, memberContext, fileFacts);
 }
-function flattenLookupValues(values2) {
-  return values2.flatMap((value) => Array.isArray(value) ? flattenLookupValues(value) : [value]);
-}
 function matchLookup(cell, field, filterCondition, looseCondition, memberContext, fileFacts) {
   switch (filterCondition.type) {
     case "select":
@@ -30302,197 +30641,378 @@ function matchCell(cell, field, filterCondition, looseCondition, memberContext,
       if (!term) return null;
       matches = files !== null && files.some((entry) => fileProperty(entry, property, fileFacts, fieldKey, filterCondition.operator).toLowerCase().includes(term));
     }
-  } else {
-    const op = typeof looseCondition.operator === "string" ? looseCondition.operator : "(unset)";
-    const source = field ? `'${String(resolvedType)}', resolved from field '${fieldKey}'` : resolvedType === void 0 ? `missing, and field '${fieldKey}' is not on this table to resolve it from` : `'${String(resolvedType)}', stated on the condition (field '${fieldKey}' is not on this table)`;
-    throw new Error(
-      `Filter condition cannot be evaluated: filter type ${source} has no evaluator. Evaluable: text, number, date, boolean, select, select_member, select_record_link, files, locked. Condition operator was "${op}".`
-    );
-  }
-  return matches;
+  } else {
+    const op = typeof looseCondition.operator === "string" ? looseCondition.operator : "(unset)";
+    const source = field ? `'${String(resolvedType)}', resolved from field '${fieldKey}'` : resolvedType === void 0 ? `missing, and field '${fieldKey}' is not on this table to resolve it from` : `'${String(resolvedType)}', stated on the condition (field '${fieldKey}' is not on this table)`;
+    throw new Error(
+      `Filter condition cannot be evaluated: filter type ${source} has no evaluator. Evaluable: text, number, date, boolean, select, select_member, select_record_link, files, locked. Condition operator was "${op}".`
+    );
+  }
+  return matches;
+}
+
+// ../shared/src/record_filter_truth.ts
+var BY_VIEWER = /* @__PURE__ */ new Set(["is_current_member", "is_not_current_member"]);
+function condition(node, subject) {
+  if (node.type === "locked" || node.type === "record_id" || node.type === "current_member") return "unknown";
+  if (node.field_key === void 0 || node.unit_option !== void 0) return "unknown";
+  if (typeof node.value === "string" && node.value.includes("{{")) return "unknown";
+  if (BY_VIEWER.has(node.operator) && subject.member_id === null) return "unknown";
+  if (FILE_NAME_OPERATORS.has(node.operator)) return "unknown";
+  const field = subject.field(node.field_key);
+  const held2 = subject.cell(node.field_key);
+  if (field === void 0 || held2 === void 0) return "unknown";
+  const decided = evaluateCondition(
+    { data: { [node.field_key]: held2.value } },
+    { [node.field_key]: field },
+    node,
+    subject.member_id === null ? null : { member_id: subject.member_id, group_ids: [] }
+  );
+  return decided === null ? "unknown" : decided;
+}
+function recordFilterTruth(filter2, subject) {
+  switch (filter2.node_type) {
+    case "condition":
+      return condition(filter2, subject);
+    case "traversal":
+      return "unknown";
+    case "group": {
+      const each = filter2.children.map((child) => recordFilterTruth(child, subject));
+      if (filter2.logic === "and") {
+        if (each.includes(false)) return false;
+        return each.every((one) => one === true) ? true : "unknown";
+      }
+      if (each.includes(true)) return true;
+      return each.every((one) => one === false) ? false : "unknown";
+    }
+  }
+}
+
+// ../shared/src/interpolate.ts
+function interpolateObject(obj, context) {
+  if (obj === null || obj === void 0) {
+    return obj;
+  }
+  if (typeof obj === "string") {
+    const expressionMatches = obj.match(/\{\{.*?\}\}/g);
+    if (expressionMatches && expressionMatches.length > 0) {
+      if (expressionMatches.length === 1 && obj === expressionMatches[0]) {
+        const expression = obj.slice(2, -2).trim();
+        return evaluateJsExpression(expression, context);
+      }
+      const parts = obj.split(/(\{\{.*?\}\})/g);
+      const evaluatedParts = parts.map((part) => {
+        if (part.startsWith("{{") && part.endsWith("}}")) {
+          const expression = part.slice(2, -2).trim();
+          const result = evaluateJsExpression(expression, context);
+          return result != null ? String(result) : "";
+        }
+        return part;
+      });
+      return evaluatedParts.join("");
+    }
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => interpolateObject(item, context));
+  }
+  if (typeof obj === "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = interpolateObject(value, context);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// ../shared/src/app_query_ast.ts
+function collectParamTokens(node, found) {
+  if (typeof node === "string") {
+    for (const tok of node.matchAll(/\{\{(.*?)\}\}/g)) {
+      for (const m of tok[1].matchAll(/\bparams\.([a-zA-Z_$][\w$]*)/g)) {
+        found.add(m[1]);
+      }
+    }
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const item of node) collectParamTokens(item, found);
+    return;
+  }
+  if (node && typeof node === "object") {
+    for (const value of Object.values(node)) collectParamTokens(value, found);
+  }
+}
+function paramTokens(node) {
+  const tokens = /* @__PURE__ */ new Set();
+  collectParamTokens(node, tokens);
+  return tokens;
+}
+function pruneFilterTree(filter2, survives) {
+  if (filter2.node_type === "group") {
+    const children = filter2.children.map((child) => pruneFilterTree(child, survives)).filter((c) => c !== void 0);
+    if (children.length === 0) return void 0;
+    return { ...filter2, children };
+  }
+  return survives.leaf(filter2) ? filter2 : void 0;
+}
+function statedParamNames(params) {
+  return new Set(Object.keys(params).filter((name) => !isUnstatedFilterValue(params[name])));
+}
+function statesNothing(leaf, params) {
+  const filled = interpolateObject(leaf.node_type === "traversal" ? leaf.condition : leaf, { params });
+  return isUnstatedConditionValue(filled.operator, filled.value);
+}
+function searchStatesNothing(search, params) {
+  const filled = interpolateObject(search, { params });
+  return typeof filled === "string" && searchWords(filled).length === 0;
+}
+function survivesCall(params) {
+  const stated = statedParamNames(params);
+  const readsOnlyStated = (node) => {
+    const tokens = paramTokens(node);
+    if (tokens.size === 0) return void 0;
+    return [...tokens].every((name) => stated.has(name));
+  };
+  return {
+    leaf: (leaf) => {
+      const reads = readsOnlyStated(leaf);
+      return reads === void 0 || reads && !statesNothing(leaf, params);
+    },
+    search: (search) => {
+      const reads = readsOnlyStated(search);
+      return reads === void 0 || reads && !searchStatesNothing(search, params);
+    }
+  };
+}
+function filterForCall(filter2, params) {
+  const pruned = pruneFilterTree(filter2, survivesCall(params));
+  return pruned === void 0 ? void 0 : interpolateObject(pruned, { params });
 }
 
-// ../shared/src/record_filter_truth.ts
-var BY_VIEWER = /* @__PURE__ */ new Set(["is_current_member", "is_not_current_member"]);
-function condition(node, subject) {
-  if (node.type === "locked" || node.type === "record_id" || node.type === "current_member") return "unknown";
-  if (node.field_key === void 0 || node.unit_option !== void 0) return "unknown";
-  if (typeof node.value === "string" && node.value.includes("{{")) return "unknown";
-  if (BY_VIEWER.has(node.operator) && subject.member_id === null) return "unknown";
-  if (FILE_NAME_OPERATORS.has(node.operator)) return "unknown";
-  const field = subject.field(node.field_key);
-  const held2 = subject.cell(node.field_key);
-  if (field === void 0 || held2 === void 0) return "unknown";
-  const decided = evaluateCondition(
-    { data: { [node.field_key]: held2.value } },
-    { [node.field_key]: field },
-    node,
-    subject.member_id === null ? null : { member_id: subject.member_id, group_ids: [] }
-  );
-  return decided === null ? "unknown" : decided;
+// ../shared/src/app_query_output_schema.ts
+function fieldTypeToColumnType(field) {
+  switch (field.type) {
+    case "text":
+      return "text";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return field.format === "datetime" || field.format === "datetime_range" ? "datetime" : "date";
+    case "select":
+      return "select";
+    case "select_member":
+      return "select_member";
+    case "select_record_link":
+      return "select_record_link";
+    case "files":
+      return "files";
+    case "rollup":
+      return rollupColumnType(field);
+    case "lookup":
+      return lookupOutputType(field);
+    case "formula":
+      return formulaOutputType(field);
+    case "button":
+      return "json";
+    case "autonumber":
+      return "text";
+    default: {
+      const _exhaustive = field;
+      void _exhaustive;
+      return "json";
+    }
+  }
 }
-function recordFilterTruth(filter2, subject) {
-  switch (filter2.node_type) {
-    case "condition":
-      return condition(filter2, subject);
-    case "traversal":
-      return "unknown";
-    case "group": {
-      const each = filter2.children.map((child) => recordFilterTruth(child, subject));
-      if (filter2.logic === "and") {
-        if (each.includes(false)) return false;
-        return each.every((one) => one === true) ? true : "unknown";
+function formulaOutputType(field) {
+  switch (field.formula.output_type) {
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return "date";
+    case "datetime":
+      return "datetime";
+    case "text":
+      return "text";
+    case "select":
+      return "select";
+    default:
+      return "json";
+  }
+}
+function rollupColumnType(field) {
+  if (rollupOutputType(field.aggregate_option.operation) === "number") return "number";
+  return field.aggregate_field_format === "datetime" || field.aggregate_field_format === "datetime_range" ? "datetime" : "date";
+}
+function lookupOutputType(field) {
+  const t = field.lookup_field_type;
+  if (!t) return "json";
+  switch (t) {
+    case "text":
+      return "text";
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    case "date":
+      return field.lookup_field_format === "datetime" || field.lookup_field_format === "datetime_range" ? "datetime" : "date";
+    case "select":
+      return "select";
+    case "select_member":
+      return "select_member";
+    case "select_record_link":
+      return "select_record_link";
+    case "files":
+      return "files";
+    default:
+      return "json";
+  }
+}
+
+// ../shared/src/field_value.ts
+function fieldValueInfo(field) {
+  switch (field.type) {
+    case "number":
+      return { type: "number", notation: fieldNotation(field) };
+    case "text":
+      return { type: "text", format: field.format };
+    case "date":
+      return { type: "date", format: field.format };
+    case "select":
+      return { type: "select", options: field.options };
+    case "formula": {
+      const output = field.formula?.output_type;
+      if (field.formula.options !== void 0) return { type: "select", options: field.formula.options };
+      if (output === "date" || output === "datetime") {
+        return { type: "date", format: output === "datetime" ? "datetime" : "date" };
       }
-      if (each.includes(true)) return true;
-      return each.every((one) => one === false) ? false : "unknown";
+      if (output === "boolean") return { type: "boolean" };
+      if (output === "text") return { type: "text", format: formulaLinks(field.formula) ? "link" : void 0 };
+      return { type: "number", notation: fieldNotation(field) };
+    }
+    case "rollup": {
+      const type = rollupOutputType(field.aggregate_option.operation);
+      return type === "number" ? { type, notation: fieldNotation(field) } : { type, format: field.aggregate_field_format };
     }
+    case "lookup":
+      return {
+        type: field.lookup_field_type ?? "text",
+        ...field.lookup_field_type === "number" ? { notation: fieldNotation(field) } : { format: field.lookup_field_format },
+        options: field.lookup_field_options,
+        autonumber: field.lookup_field_autonumber
+      };
+    // The cell stores the composed DISPLAY string ("KH-001"), never the counter.
+    case "autonumber":
+      return { type: "text", autonumber: true };
+    default:
+      return { type: field.type };
   }
 }
 
 // ../shared/src/field_comparison.ts
-var SIMPLE_LOOKUP_TYPES = /* @__PURE__ */ new Set([
-  "text",
-  "number",
-  "date",
-  "boolean",
-  "formula",
-  "rollup",
-  "files"
-]);
-function isArrayFieldEmpty(value) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (!Array.isArray(value)) {
-    return false;
+var MemberNamesUnavailableError = class extends Error {
+  constructor(fieldKey) {
+    super(
+      `Comparing "${fieldKey}" orders members by name, and its cells hold member ids \u2014 the workspace's member names must be supplied to compare them.`
+    );
+    this.name = "MemberNamesUnavailableError";
   }
-  if (value.length === 0) {
-    return true;
+};
+function firstMember(cell) {
+  const first2 = Array.isArray(cell) ? cell[0] : void 0;
+  return typeof first2 === "string" ? first2 : void 0;
+}
+function firstLink(cell) {
+  const first2 = Array.isArray(cell) ? cell[0] : void 0;
+  if (typeof first2 !== "object" || first2 === null || !("id" in first2) || typeof first2.id !== "string") return void 0;
+  const display = "display" in first2 && typeof first2.display === "string" ? first2.display : "";
+  return { name: display, id: first2.id };
+}
+function folded(text2) {
+  return text2.trim().toLowerCase();
+}
+function compareNamed(a, b) {
+  const byName = folded(a.name).localeCompare(folded(b.name), "en-US");
+  return byName !== 0 ? byName : a.id.localeCompare(b.id, "en-US");
+}
+function optionRank(cell, options) {
+  const first2 = Array.isArray(cell) ? cell[0] : void 0;
+  if (first2 === void 0 || first2 === null) return void 0;
+  const at2 = options.findIndex((option) => option.key === first2);
+  return { by: "figure", value: at2 === -1 ? options.length : at2 };
+}
+function valueRank(cell, type) {
+  if (cell === void 0 || cell === null) return void 0;
+  switch (type) {
+    case "number":
+      return typeof cell === "number" && Number.isFinite(cell) ? { by: "figure", value: cell } : void 0;
+    case "boolean":
+      return typeof cell === "boolean" ? { by: "figure", value: cell ? 1 : 0 } : void 0;
+    case "date":
+    case "datetime":
+      return typeof cell === "string" && /^\d{4}/.test(cell) ? { by: "day", value: cell } : void 0;
+    case "text":
+      return { by: "text", value: folded(String(cell)) };
+    case "select_member": {
+      const id = firstMember(cell);
+      return id === void 0 ? void 0 : { by: "member", id };
+    }
+    case "select_record_link": {
+      const link2 = firstLink(cell);
+      return link2 === void 0 ? void 0 : { by: "name", value: link2 };
+    }
+    case "files":
+      return Array.isArray(cell) ? { by: "figure", value: cell.length } : void 0;
+    case "select":
+    case "json":
+      return typeof cell === "number" ? { by: "figure", value: cell } : { by: "text", value: folded(String(cell)) };
+  }
+}
+function autonumberTerms(cell) {
+  if (cell === void 0 || cell === null) return [void 0, void 0];
+  const text2 = String(cell);
+  return /^-?\d+$/.test(text2) ? [{ by: "figure", value: Number(text2) }, void 0] : [void 0, { by: "text", value: text2 }];
+}
+function termsOf(cell, field) {
+  const value = field.type === "lookup" && Array.isArray(cell) ? cell[0] : cell;
+  if (fieldValueInfo(field).autonumber === true) return autonumberTerms(value);
+  const options = effectiveSelectOptions(field);
+  return [options === null ? valueRank(value, fieldTypeToColumnType(field)) : optionRank(value, options)];
+}
+function rankText(rank) {
+  if (rank.by === "name") return folded(rank.value.name);
+  if (rank.by === "member") return rank.id;
+  return String(rank.value);
+}
+function compareFieldValues(aValue, bValue, field, { blank = "bottom", order = "asc", memberNames } = {}) {
+  if (aValue === bValue) return 0;
+  const a = termsOf(aValue, field);
+  const b = termsOf(bValue, field);
+  const member = (id) => {
+    if (memberNames === void 0) throw new MemberNamesUnavailableError(field.key);
+    return { name: memberNames.get(id) ?? "", id };
+  };
+  for (const [at2, left] of a.entries()) {
+    const right = b[at2];
+    if (left === void 0 && right === void 0) continue;
+    if (left === void 0) return blank === "top" ? -1 : 1;
+    if (right === void 0) return blank === "top" ? 1 : -1;
+    const compared = compareRanks(left, right, member);
+    if (compared !== 0) return order === "asc" ? compared : -compared;
   }
-  return value[0] === void 0 || value[0] === null;
+  return 0;
 }
-function compareFieldValues(aValue, bValue, field, blankPosition = "bottom", order = "asc") {
-  if (aValue === bValue) {
-    return 0;
-  }
-  const options = selectOptionsOf(field);
-  if (options !== void 0) {
-    const aSelectArray = Array.isArray(aValue) ? aValue : null;
-    const bSelectArray = Array.isArray(bValue) ? bValue : null;
-    const aSelectValue = aSelectArray?.[0];
-    const bSelectValue = bSelectArray?.[0];
-    const aIsEmpty2 = isArrayFieldEmpty(aSelectArray);
-    const bIsEmpty2 = isArrayFieldEmpty(bSelectArray);
-    if (aIsEmpty2 && bIsEmpty2) {
-      return 0;
-    }
-    if (aIsEmpty2) {
-      return blankPosition === "top" ? -1 : 1;
-    }
-    if (bIsEmpty2) {
-      return blankPosition === "top" ? 1 : -1;
-    }
-    const aIndex = options.findIndex((option) => option.key === aSelectValue);
-    const bIndex = options.findIndex((option) => option.key === bSelectValue);
-    const aPosition = aIndex === -1 ? Number.MAX_SAFE_INTEGER : aIndex;
-    const bPosition = bIndex === -1 ? Number.MAX_SAFE_INTEGER : bIndex;
-    const diff = aPosition - bPosition;
-    return order === "asc" ? diff : -diff;
-  }
-  const aIsEmpty = aValue === void 0 || aValue === null;
-  const bIsEmpty = bValue === void 0 || bValue === null;
-  if (aIsEmpty && bIsEmpty) {
-    return 0;
-  }
-  if (aIsEmpty) {
-    return blankPosition === "top" ? -1 : 1;
-  }
-  if (bIsEmpty) {
-    return blankPosition === "top" ? 1 : -1;
-  }
-  if (field.type === "number" || field.type === "rollup" || field.type === "formula") {
-    const diff = aValue - bValue;
-    return order === "asc" ? diff : -diff;
-  }
-  if (field.type === "boolean") {
-    const aBool = aValue;
-    const bBool = bValue;
-    if (aBool === bBool) return 0;
-    const diff = aBool === true ? 1 : -1;
-    return order === "asc" ? diff : -diff;
-  }
-  if (field.type === "date") {
-    const aStr = String(aValue);
-    const bStr = String(bValue);
-    const cmp = aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
-    return order === "asc" ? cmp : -cmp;
-  }
-  if (field.type === "files") {
-    const aFiles = aValue;
-    const bFiles = bValue;
-    const aLength = aFiles?.length || 0;
-    const bLength = bFiles?.length || 0;
-    const diff = aLength - bLength;
-    return order === "asc" ? diff : -diff;
-  }
-  if (field.type === "select_member") {
-    const aArray = aValue ?? [];
-    const bArray = bValue ?? [];
-    const aIsEmpty2 = isArrayFieldEmpty(aArray);
-    const bIsEmpty2 = isArrayFieldEmpty(bArray);
-    if (aIsEmpty2 && bIsEmpty2) {
-      return 0;
-    }
-    if (aIsEmpty2) {
-      return blankPosition === "top" ? -1 : 1;
-    }
-    if (bIsEmpty2) {
-      return blankPosition === "top" ? 1 : -1;
-    }
-    const aString2 = String(aArray[0] || "");
-    const bString2 = String(bArray[0] || "");
-    const compareResult2 = aString2.localeCompare(bString2, "en-US");
-    return order === "asc" ? compareResult2 : -compareResult2;
-  }
-  if (field.type === "select_record_link") {
-    const aItems = aValue ?? [];
-    const bItems = bValue ?? [];
-    const aIsEmpty2 = aItems.length === 0;
-    const bIsEmpty2 = bItems.length === 0;
-    if (aIsEmpty2 && bIsEmpty2) {
-      return 0;
-    }
-    if (aIsEmpty2) {
-      return blankPosition === "top" ? -1 : 1;
-    }
-    if (bIsEmpty2) {
-      return blankPosition === "top" ? 1 : -1;
-    }
-    const aString2 = aItems[0]?.display ?? "";
-    const bString2 = bItems[0]?.display ?? "";
-    const compareResult2 = aString2.localeCompare(bString2, "en-US");
-    return order === "asc" ? compareResult2 : -compareResult2;
-  }
-  if (field.type === "lookup") {
-    const lookupField = field;
-    const aArr = Array.isArray(aValue) ? aValue : [aValue];
-    const bArr = Array.isArray(bValue) ? bValue : [bValue];
-    const aFirst = aArr[0] ?? null;
-    const bFirst = bArr[0] ?? null;
-    const sourceType = lookupField.lookup_field_type || "text";
-    if (SIMPLE_LOOKUP_TYPES.has(sourceType)) {
-      const syntheticField = { ...field, type: sourceType };
-      return compareFieldValues(aFirst, bFirst, syntheticField, blankPosition, order);
-    }
-    const aString2 = String(aFirst ?? "");
-    const bString2 = String(bFirst ?? "");
-    const cmp = aString2.localeCompare(bString2, "en-US");
-    return order === "asc" ? cmp : -cmp;
-  }
-  const aString = String(aValue || "");
-  const bString = String(bValue || "");
-  const compareResult = aString.localeCompare(bString, "en-US");
-  return order === "asc" ? compareResult : -compareResult;
+function compareRanks(a, b, member) {
+  if (a.by === "figure" && b.by === "figure") return a.value - b.value;
+  if (a.by === "day" && b.by === "day") return a.value < b.value ? -1 : a.value > b.value ? 1 : 0;
+  if (a.by === "name" && b.by === "name") return compareNamed(a.value, b.value);
+  if (a.by === "member" && b.by === "member") return compareNamed(member(a.id), member(b.id));
+  return rankText(a).localeCompare(rankText(b), "en-US");
 }
 
 // ../shared/src/formula_references.ts
@@ -30566,7 +31086,7 @@ function prepareFormulaContext(fields) {
     nonFormulaFields
   };
 }
-function computeFormulaFieldsWithContext(row2, fields, context, linkedTableRecords = /* @__PURE__ */ new Map(), linkedTableFields = /* @__PURE__ */ new Map(), timezone, loadedLinkKeys, linkExpandedTableIds, fileFacts) {
+function computeFormulaFieldsWithContext(row2, fields, context, linkedTableRecords = /* @__PURE__ */ new Map(), linkedTableFields = /* @__PURE__ */ new Map(), timezone, loadedLinkKeys, linkExpandedTableIds, fileFacts, memberNames) {
   const result = { ...row2 };
   const mayRecompute = (linkKey) => loadedLinkKeys === void 0 || loadedLinkKeys.has(linkKey) || isEmptyFieldValue(row2[linkKey]);
   for (const { field, sourceField } of context.rollupFields) {
@@ -30631,7 +31151,8 @@ function computeFormulaFieldsWithContext(row2, fields, context, linkedTableRecor
         field.lookup_field_key,
         linkedField,
         field.order_by,
-        linkedFieldsArray
+        linkedFieldsArray,
+        memberNames
       );
       result[field.key] = lookupValue;
     } else {
@@ -30961,7 +31482,7 @@ function calculateRollupValue(value, fieldType, allLinkedTableRecords, aggregate
   }
   return aggregateByField(relevantRecords, fieldType, aggregateOption, subject).result;
 }
-function calculateLookupValue(value, linkedRecords, lookupFieldKey, linkedField, orderBy, linkedFields) {
+function calculateLookupValue(value, linkedRecords, lookupFieldKey, linkedField, orderBy, linkedFields, memberNames) {
   if (!linkedRecords.length || !lookupFieldKey) {
     return null;
   }
@@ -30986,13 +31507,11 @@ function calculateLookupValue(value, linkedRecords, lookupFieldKey, linkedField,
       return null;
     }
     const picked = [...relevantRecords].sort((a, b) => {
-      const cmp = compareFieldValues(
-        a.data[orderField.key],
-        b.data[orderField.key],
-        orderField,
-        "bottom",
-        orderBy.direction
-      );
+      const cmp = compareFieldValues(a.data[orderField.key], b.data[orderField.key], orderField, {
+        blank: "bottom",
+        order: orderBy.direction,
+        memberNames
+      });
       if (cmp !== 0) return cmp;
       if (a.created_at !== b.created_at) return a.created_at < b.created_at ? 1 : -1;
       return a.id < b.id ? 1 : a.id > b.id ? -1 : 0;
@@ -31008,109 +31527,6 @@ function calculateLookupValue(value, linkedRecords, lookupFieldKey, linkedField,
   return values2.length > 0 ? values2 : null;
 }
 
-// ../shared/src/interpolate.ts
-function interpolateObject(obj, context) {
-  if (obj === null || obj === void 0) {
-    return obj;
-  }
-  if (typeof obj === "string") {
-    const expressionMatches = obj.match(/\{\{.*?\}\}/g);
-    if (expressionMatches && expressionMatches.length > 0) {
-      if (expressionMatches.length === 1 && obj === expressionMatches[0]) {
-        const expression = obj.slice(2, -2).trim();
-        return evaluateJsExpression(expression, context);
-      }
-      const parts = obj.split(/(\{\{.*?\}\})/g);
-      const evaluatedParts = parts.map((part) => {
-        if (part.startsWith("{{") && part.endsWith("}}")) {
-          const expression = part.slice(2, -2).trim();
-          const result = evaluateJsExpression(expression, context);
-          return result != null ? String(result) : "";
-        }
-        return part;
-      });
-      return evaluatedParts.join("");
-    }
-    return obj;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => interpolateObject(item, context));
-  }
-  if (typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = interpolateObject(value, context);
-    }
-    return result;
-  }
-  return obj;
-}
-
-// ../shared/src/app_query_ast.ts
-function collectParamTokens(node, found) {
-  if (typeof node === "string") {
-    for (const tok of node.matchAll(/\{\{(.*?)\}\}/g)) {
-      for (const m of tok[1].matchAll(/\bparams\.([a-zA-Z_$][\w$]*)/g)) {
-        found.add(m[1]);
-      }
-    }
-    return;
-  }
-  if (Array.isArray(node)) {
-    for (const item of node) collectParamTokens(item, found);
-    return;
-  }
-  if (node && typeof node === "object") {
-    for (const value of Object.values(node)) collectParamTokens(value, found);
-  }
-}
-function paramTokens(node) {
-  const tokens = /* @__PURE__ */ new Set();
-  collectParamTokens(node, tokens);
-  return tokens;
-}
-function pruneFilterTree(filter2, survives) {
-  if (filter2.node_type === "group") {
-    const children = filter2.children.map((child) => pruneFilterTree(child, survives)).filter((c) => c !== void 0);
-    if (children.length === 0) return void 0;
-    return { ...filter2, children };
-  }
-  return survives.leaf(filter2) ? filter2 : void 0;
-}
-function statedParamNames(params) {
-  return new Set(Object.keys(params).filter((name) => !isUnstatedFilterValue(params[name])));
-}
-function statesNothing(leaf, params) {
-  const filled = interpolateObject(leaf.node_type === "traversal" ? leaf.condition : leaf, { params });
-  return isUnstatedConditionValue(filled.operator, filled.value);
-}
-function searchStatesNothing(search, params) {
-  const filled = interpolateObject(search, { params });
-  return typeof filled === "string" && searchWords(filled).length === 0;
-}
-function survivesCall(params) {
-  const stated = statedParamNames(params);
-  const readsOnlyStated = (node) => {
-    const tokens = paramTokens(node);
-    if (tokens.size === 0) return void 0;
-    return [...tokens].every((name) => stated.has(name));
-  };
-  return {
-    leaf: (leaf) => {
-      const reads = readsOnlyStated(leaf);
-      return reads === void 0 || reads && !statesNothing(leaf, params);
-    },
-    search: (search) => {
-      const reads = readsOnlyStated(search);
-      return reads === void 0 || reads && !searchStatesNothing(search, params);
-    }
-  };
-}
-function filterForCall(filter2, params) {
-  const pruned = pruneFilterTree(filter2, survivesCall(params));
-  return pruned === void 0 ? void 0 : interpolateObject(pruned, { params });
-}
-
 // src/overlay.ts
 var NONE2 = /* @__PURE__ */ new Set();
 function fieldKeyOf(shape, column, tableId) {