@lotics/app-sdk 0.115.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,179 +24236,67 @@ function everyOptionMarked(nameOf2) {
   };
 }
 
-// ../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]);
+// ../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;
 }
-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/diacritics.ts
 var COMBINING_MARKS = /[̀-ͯ]/g;
@@ -24738,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 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 tableNumberFieldSchema = tableFieldBaseSchema.extend({
+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"),
@@ -24846,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."
   ),
@@ -24873,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."
   ),
@@ -24885,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."
   )
@@ -24897,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(
@@ -24971,7 +25157,7 @@ var tableFieldSchema = zod_default.discriminatedUnion("type", [
   tableAutonumberFieldSchema
 ]);
 var tableFieldInputSchema = zod_default.discriminatedUnion("type", [
-  tableNumberFieldSchema,
+  tableNumberFieldInputSchema,
   tableTextFieldSchema,
   tableDateFieldSchema,
   tableBooleanFieldSchema,
@@ -24981,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"),
@@ -25004,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: currencyCodeSchema.optional(),
-    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"),
@@ -25074,8 +25268,8 @@ var tableFieldTypeConfigSchema = zod_default.discriminatedUnion("type", [
   }),
   zod_default.object({
     type: zod_default.literal("formula"),
-    formula: formulaInputSchema.extend({ currency: currencyCodeSchema.optional() })
-  }).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
@@ -28289,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";
@@ -30027,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":
@@ -30494,150 +30688,331 @@ function recordFilterTruth(filter2, subject) {
   }
 }
 
-// ../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;
+// ../shared/src/interpolate.ts
+function interpolateObject(obj, context) {
+  if (obj === null || obj === void 0) {
+    return obj;
   }
-  if (!Array.isArray(value)) {
-    return false;
+  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 (value.length === 0) {
-    return true;
+  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 value[0] === void 0 || value[0] === null;
+  return obj;
 }
-function compareFieldValues(aValue, bValue, field, blankPosition = "bottom", order = "asc") {
-  if (aValue === bValue) {
-    return 0;
+
+// ../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;
   }
-  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 (Array.isArray(node)) {
+    for (const item of node) collectParamTokens(item, found);
+    return;
   }
-  if (aIsEmpty) {
-    return blankPosition === "top" ? -1 : 1;
+  if (node && typeof node === "object") {
+    for (const value of Object.values(node)) collectParamTokens(value, found);
   }
-  if (bIsEmpty) {
-    return blankPosition === "top" ? 1 : -1;
+}
+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/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";
+    }
   }
-  if (field.type === "number" || field.type === "rollup" || field.type === "formula") {
-    const diff = aValue - bValue;
-    return order === "asc" ? diff : -diff;
+}
+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";
   }
-  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 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 (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 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";
+  }
+};
+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 0;
+}
+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
@@ -30711,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) {
@@ -30776,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 {
@@ -31106,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;
   }
@@ -31131,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;
@@ -31153,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) {