@stndrds/schema 1.0.0-alpha.192 → 1.0.0-alpha.194

package/dist/index.js

@@ -2,27 +2,25 @@
 
 var chunkFRCDMQER_js = require('./chunk-FRCDMQER.js');
 require('./chunk-PGERPYDR.js');
-var chunkYQROI4IE_js = require('./chunk-YQROI4IE.js');
-var chunkFQ2ZYOVS_js = require('./chunk-FQ2ZYOVS.js');
-require('./chunk-MAKSIK3P.js');
-require('./chunk-J5HRK3WD.js');
-require('./chunk-TKN73433.js');
-require('./chunk-D7WFIGXW.js');
-require('./chunk-3JINFUN3.js');
-require('./chunk-QWZHR2OO.js');
-require('./chunk-EZHMVZQ4.js');
-require('./chunk-VXOTYFEW.js');
-require('./chunk-OAQWRMTP.js');
-require('./chunk-ACQ3TUFK.js');
-require('./chunk-DC7YYE3U.js');
-require('./chunk-ROAZLZA2.js');
-require('./chunk-CCB4OY2O.js');
-var chunk7A3Y6O32_js = require('./chunk-7A3Y6O32.js');
-require('./chunk-P2BE2A2G.js');
-var chunkT225DB55_js = require('./chunk-T225DB55.js');
+var chunkM5QIBMIH_js = require('./chunk-M5QIBMIH.js');
+var chunkMZOEL7FN_js = require('./chunk-MZOEL7FN.js');
+require('./chunk-5WATIVCA.js');
+require('./chunk-O44XVGHE.js');
+require('./chunk-YIP5FJ5H.js');
+require('./chunk-SGSGREPG.js');
+require('./chunk-EW5XR2X3.js');
+require('./chunk-QWKLQRBX.js');
+require('./chunk-T6L2MUG2.js');
+require('./chunk-HTSTPTNZ.js');
+require('./chunk-V2UA2D4E.js');
+require('./chunk-ACKMC6FL.js');
+require('./chunk-ROLWVTU3.js');
+require('./chunk-E6JUYGJX.js');
+var chunkEBGRZUIH_js = require('./chunk-EBGRZUIH.js');
+require('./chunk-BV3IUMMW.js');
+var chunkYKWSHBT5_js = require('./chunk-YKWSHBT5.js');
 var constants = require('@stndrds/constants');
 var z3 = require('zod');
-var exprEval = require('expr-eval');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -32,7 +30,6 @@ var z3__default = /*#__PURE__*/_interopDefault(z3);
 var IDENTITY_PROPERTIES = ["name", "type"];
 var BEHAVIOR_PROPERTIES = [
   "required",
-  "disabled",
   "hidden",
   "archived",
   "deprecated",
@@ -43,6 +40,318 @@ var BEHAVIOR_PROPERTIES = [
 ];
 var PRESENTATION_PROPERTIES = ["label", "description", "placeholder", "icon"];
 
+// src/types/attribute-capabilities.ts
+var TEXT_OPERATORS = [
+  "is",
+  "is_not",
+  "contains",
+  "not_contains",
+  "starts_with",
+  "ends_with",
+  "is_empty",
+  "is_not_empty"
+];
+var NUMBER_OPERATORS = [
+  "eq",
+  "neq",
+  "lt",
+  "gt",
+  "lte",
+  "gte",
+  "is_empty",
+  "is_not_empty"
+];
+var CHECKBOX_OPERATORS = [
+  "is_checked",
+  "is_not_checked"
+];
+var DATE_OPERATORS = [
+  "is",
+  "is_not",
+  "before",
+  "after",
+  "on_or_before",
+  "on_or_after",
+  "is_within",
+  "day_month_eq",
+  "is_empty",
+  "is_not_empty"
+];
+var SELECT_OPERATORS = [
+  "is",
+  "is_not",
+  "any_of",
+  "none_of",
+  "is_empty",
+  "is_not_empty"
+];
+var MULTISELECT_OPERATORS = [
+  "contains",
+  "not_contains",
+  "is_empty",
+  "is_not_empty"
+];
+var REFERENCE_OPERATORS = [
+  "is",
+  "is_not",
+  "any_of",
+  "none_of",
+  "contains",
+  "not_contains",
+  "is_empty",
+  "is_not_empty"
+];
+var PRESENCE_OPERATORS = [
+  "is_empty",
+  "is_not_empty"
+];
+var FORMULA_OPERATORS = [
+  "is",
+  "is_not",
+  "eq",
+  "neq",
+  "lt",
+  "gt",
+  "lte",
+  "gte",
+  "contains",
+  "not_contains",
+  "is_empty",
+  "is_not_empty"
+];
+var ATTRIBUTE_FILTER_OPERATORS = {
+  text: TEXT_OPERATORS,
+  richtext: [],
+  number: NUMBER_OPERATORS,
+  checkbox: CHECKBOX_OPERATORS,
+  date: DATE_OPERATORS,
+  phone: ["is", "is_not", "contains", "not_contains", "is_empty", "is_not_empty"],
+  currency: NUMBER_OPERATORS,
+  status: SELECT_OPERATORS,
+  select: SELECT_OPERATORS,
+  multiselect: MULTISELECT_OPERATORS,
+  location: [],
+  file: PRESENCE_OPERATORS,
+  user: REFERENCE_OPERATORS,
+  relation: REFERENCE_OPERATORS,
+  formula: FORMULA_OPERATORS,
+  document: PRESENCE_OPERATORS
+};
+var COMPUTED_TYPES = /* @__PURE__ */ new Set(["formula", "rollup"]);
+var EDGE_BACKED_TYPES = /* @__PURE__ */ new Set(["file", "user", "relation", "document"]);
+var DIRECT_EDIT_TYPES = /* @__PURE__ */ new Set(["checkbox"]);
+var STATIC_DEFAULT_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "richtext",
+  "number",
+  "select",
+  "multiselect",
+  "status",
+  "date",
+  "phone",
+  "currency",
+  "location",
+  "user",
+  "file",
+  "relation",
+  "document"
+]);
+var PLACEHOLDER_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "number",
+  "date",
+  "phone",
+  "currency",
+  "select",
+  "multiselect"
+]);
+var SEARCHABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "phone",
+  "status",
+  "select",
+  "multiselect"
+]);
+var SORTABLE_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "number",
+  "checkbox",
+  "date",
+  "phone",
+  "currency",
+  "status",
+  "select"
+]);
+function getAttributeCapabilities(attribute) {
+  const suppressed = Boolean(attribute.hidden || attribute.archived);
+  const active = !attribute.archived;
+  const computed = COMPUTED_TYPES.has(attribute.type);
+  const document2 = attribute.type === "document";
+  const edgeBacked = EDGE_BACKED_TYPES.has(attribute.type);
+  const cardinality = getAttributeCardinality(attribute);
+  const operators = suppressed ? [] : getRawFilterOperators(attribute);
+  const filterable = operators.length > 0 && !suppressed;
+  const searchable = !suppressed && SEARCHABLE_TYPES.has(attribute.type);
+  const sortable = !suppressed && SORTABLE_TYPES.has(attribute.type);
+  const groupable = !suppressed && isGroupableType(attribute.type);
+  const kanbanGroupable = !suppressed && attribute.type === "status";
+  const readOnly = computed || document2;
+  const editable = !(suppressed || readOnly);
+  const required = isRequiredForbidden(attribute.type) ? "forbidden" : "allowed";
+  const defaultValue = getDefaultValueCapability(attribute.type);
+  const maxItems = supportsMaxItems(attribute);
+  const placeholder = PLACEHOLDER_TYPES.has(attribute.type);
+  const warningWhenDeprecated = Boolean(attribute.deprecated && !suppressed);
+  return {
+    lifecycle: {
+      active,
+      deprecated: Boolean(attribute.deprecated),
+      visibleInArchitect: true,
+      visibleInRuntime: !suppressed,
+      warningWhenDeprecated
+    },
+    storage: {
+      mode: computed ? "computed" : edgeBacked ? "edge" : "value",
+      cardinality,
+      edgeBacked,
+      preservesExistingValues: Boolean(attribute.archived),
+      qualifiedProperties: supportsQualifiedProperties(attribute.type),
+      polymorphic: getPolymorphicCapability(attribute),
+      maxItems
+    },
+    authoring: {
+      editable,
+      readOnly,
+      directEdit: editable && DIRECT_EDIT_TYPES.has(attribute.type),
+      required,
+      defaultValue,
+      placeholder,
+      maxItems
+    },
+    presentation: {
+      formField: !suppressed && isFormFieldType(attribute.type),
+      tableCell: !suppressed && isTableCellType(attribute.type),
+      defaultColumn: !suppressed && isDefaultColumnType(attribute.type),
+      compactDisplay: !suppressed,
+      popoverEditor: !suppressed && isPopoverEditorType(attribute.type),
+      placeholder,
+      warningWhenDeprecated
+    },
+    query: {
+      filterable,
+      searchable,
+      sortable,
+      groupable,
+      kanbanGroupable,
+      operators
+    },
+    agent: {
+      readable: !suppressed,
+      writable: editable && !document2,
+      compactReadable: !suppressed,
+      contentReadable: !suppressed && isContentReadableType(attribute.type),
+      requiresDedicatedTool: document2
+    },
+    exchange: {
+      importable: !suppressed,
+      exportable: !suppressed,
+      schemaExportable: true,
+      metadataExportable: false
+    }
+  };
+}
+function getAttributeFilterOperators(attribute) {
+  return getAttributeCapabilities(attribute).query.operators;
+}
+function isAttributeFilterable(attribute) {
+  return getAttributeCapabilities(attribute).query.filterable;
+}
+function isAttributeSearchable(attribute) {
+  return getAttributeCapabilities(attribute).query.searchable;
+}
+function isAttributeSortable(attribute) {
+  return getAttributeCapabilities(attribute).query.sortable;
+}
+function isAttributeGroupable(attribute) {
+  return getAttributeCapabilities(attribute).query.groupable;
+}
+function isAttributeKanbanGroupable(attribute) {
+  return getAttributeCapabilities(attribute).query.kanbanGroupable;
+}
+function getRollupFilterOperators(attr) {
+  const fn = attr.function;
+  if (fn === "earliest" || fn === "latest") {
+    return ATTRIBUTE_FILTER_OPERATORS.date;
+  }
+  if (fn === "original") {
+    const targetType = attr.targetAttributeType;
+    if (targetType && hasFilterOperatorEntry(targetType)) {
+      return ATTRIBUTE_FILTER_OPERATORS[targetType];
+    }
+    return ATTRIBUTE_FILTER_OPERATORS.number;
+  }
+  return ATTRIBUTE_FILTER_OPERATORS.number;
+}
+function getRawFilterOperators(attribute) {
+  if (attribute.type === "rollup") {
+    return getRollupFilterOperators(attribute);
+  }
+  return ATTRIBUTE_FILTER_OPERATORS[attribute.type] ?? [];
+}
+function getAttributeCardinality(attribute) {
+  if (attribute.type === "multiselect" || attribute.type === "document") return "many";
+  if (attribute.type === "file" && attribute.multiple === true) return "many";
+  if (attribute.type === "user" && attribute.multiple === true) return "many";
+  if (attribute.type === "relation") return attribute.cardinality === "many" ? "many" : "one";
+  return "one";
+}
+function getPolymorphicCapability(attribute) {
+  if (attribute.type !== "relation") return "none";
+  const relation2 = attribute;
+  const targets = relation2.targets ?? [];
+  if (targets.length === 1 && targets[0]?.object === "*") return "internal";
+  return targets.length > 1 ? "code-only" : "none";
+}
+function supportsMaxItems(attribute) {
+  if (attribute.type === "multiselect") return true;
+  if (attribute.type === "relation") return attribute.cardinality === "many";
+  if (attribute.type === "file") return attribute.multiple === true;
+  return false;
+}
+function supportsQualifiedProperties(type) {
+  return type === "relation" || type === "document";
+}
+function isRequiredForbidden(type) {
+  return type === "checkbox" || type === "formula" || type === "rollup";
+}
+function getDefaultValueCapability(type) {
+  if (type === "checkbox") return "automatic";
+  if (type === "formula" || type === "rollup") return "forbidden";
+  if (STATIC_DEFAULT_TYPES.has(type)) return "static";
+  return "forbidden";
+}
+function isDefaultColumnType(type) {
+  return isTableCellType(type);
+}
+function isTableCellType(type) {
+  return type !== "richtext" && type !== "file" && type !== "document";
+}
+function isFormFieldType(type) {
+  return type !== "richtext";
+}
+function isPopoverEditorType(type) {
+  return type === "select" || type === "status" || type === "multiselect" || type === "relation" || type === "user";
+}
+function isGroupableType(type) {
+  return type === "status" || type === "currency";
+}
+function isContentReadableType(type) {
+  return type === "richtext" || type === "document";
+}
+function hasFilterOperatorEntry(type) {
+  return Object.prototype.hasOwnProperty.call(ATTRIBUTE_FILTER_OPERATORS, type);
+}
+
 // src/types/attributes.ts
 var RELATION_TARGET_ANY = "*";
 function isUniversalRelation(attr) {
@@ -54,17 +363,8 @@ function isBilateralRelation(attr) {
 function inferInverseCardinality(cardinality) {
   return cardinality === "one" ? "many" : "many";
 }
-var NON_SORTABLE_TYPES = /* @__PURE__ */ new Set([
-  "richtext",
-  "file",
-  "document",
-  "location",
-  "user",
-  "multiselect",
-  "relation"
-]);
-function isAttributeSortable(attr) {
-  return !NON_SORTABLE_TYPES.has(attr.type);
+function isAttributeSortable2(attr) {
+  return isAttributeSortable(attr);
 }
 
 // src/types/document-layout.ts
@@ -86,95 +386,7 @@ function getErrorMessage(error) {
 }
 
 // src/types/filters.ts
-var OPERATORS_BY_TYPE = {
-  text: [
-    "is",
-    "is_not",
-    "contains",
-    "not_contains",
-    "starts_with",
-    "ends_with",
-    "is_empty",
-    "is_not_empty"
-  ],
-  textarea: [
-    "is",
-    "is_not",
-    "contains",
-    "not_contains",
-    "starts_with",
-    "ends_with",
-    "is_empty",
-    "is_not_empty"
-  ],
-  richtext: ["is_empty", "is_not_empty"],
-  number: ["eq", "neq", "lt", "gt", "lte", "gte", "is_empty", "is_not_empty"],
-  checkbox: ["is_checked", "is_not_checked"],
-  date: [
-    "is",
-    "is_not",
-    "before",
-    "after",
-    "on_or_before",
-    "on_or_after",
-    "is_within",
-    "day_month_eq",
-    "is_empty",
-    "is_not_empty"
-  ],
-  phone: ["is", "is_not", "contains", "not_contains", "is_empty", "is_not_empty"],
-  currency: ["eq", "neq", "lt", "gt", "lte", "gte", "is_empty", "is_not_empty"],
-  status: ["is", "is_not", "any_of", "none_of", "is_empty", "is_not_empty"],
-  select: ["is", "is_not", "any_of", "none_of", "is_empty", "is_not_empty"],
-  multiselect: ["contains", "not_contains", "is_empty", "is_not_empty"],
-  location: ["contains", "is_empty", "is_not_empty"],
-  // Reference attribute types (user, relation) all route through the edge
-  // filter resolver, which normalizes is/is_not/any_of/none_of/contains/
-  // not_contains via `getOperatorPolarity` + `normalizeForEdgeRpc`. Keep the
-  // operator lists symmetric so the schema validation matches what the runtime
-  // actually supports.
-  // File and document attributes only expose presence operators — qualified
-  // filters (via `.qualifyWith()` on document) keep their own operator set
-  // based on the property type.
-  file: ["is_empty", "is_not_empty"],
-  user: [
-    "is",
-    "is_not",
-    "any_of",
-    "none_of",
-    "contains",
-    "not_contains",
-    "is_empty",
-    "is_not_empty"
-  ],
-  relation: [
-    "is",
-    "is_not",
-    "any_of",
-    "none_of",
-    "contains",
-    "not_contains",
-    "is_empty",
-    "is_not_empty"
-  ],
-  rating: ["eq", "neq", "lt", "gt", "lte", "gte", "is_empty", "is_not_empty"],
-  // Formula: operators depend on returnType, but we provide a general set
-  formula: [
-    "is",
-    "is_not",
-    "eq",
-    "neq",
-    "lt",
-    "gt",
-    "lte",
-    "gte",
-    "contains",
-    "not_contains",
-    "is_empty",
-    "is_not_empty"
-  ],
-  document: ["is_empty", "is_not_empty"]
-};
+var OPERATORS_BY_TYPE = ATTRIBUTE_FILTER_OPERATORS;
 var NO_VALUE_OPERATORS = [
   "is_empty",
   "is_not_empty",
@@ -184,19 +396,8 @@ var NO_VALUE_OPERATORS = [
 function isNoValueOperator(operator) {
   return NO_VALUE_OPERATORS.includes(operator);
 }
-function getRollupFilterOperators(attr) {
-  const fn = attr.function;
-  if (fn === "earliest" || fn === "latest") {
-    return OPERATORS_BY_TYPE.date;
-  }
-  if (fn === "original") {
-    const targetType = attr.targetAttributeType;
-    if (targetType && Object.prototype.hasOwnProperty.call(OPERATORS_BY_TYPE, targetType)) {
-      return OPERATORS_BY_TYPE[targetType];
-    }
-    return OPERATORS_BY_TYPE.number;
-  }
-  return OPERATORS_BY_TYPE.number;
+function getRollupFilterOperators2(attr) {
+  return getRollupFilterOperators(attr);
 }
 
 // src/types/forms/definition.ts
@@ -314,7 +515,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Created time",
     type: "date",
     required: false,
-    disabled: true,
     system: true,
     icon: "clock-circle",
     description: "When this record was created"
@@ -325,7 +525,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Last edited time",
     type: "date",
     required: false,
-    disabled: true,
     system: true,
     icon: "clock-circle",
     description: "When this record was last modified"
@@ -336,7 +535,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Created by",
     type: "user",
     required: false,
-    disabled: true,
     system: true,
     multiple: false,
     icon: "user",
@@ -348,7 +546,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Last edited by",
     type: "user",
     required: false,
-    disabled: true,
     system: true,
     multiple: false,
     icon: "user",
@@ -365,8 +562,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Attachments",
     type: "document",
     required: false,
-    disabled: false,
-    // Editable via Documents tab
     system: true,
     hidden: true,
     // Hidden from regular form views
@@ -462,7 +657,6 @@ function validateSlotAgainstConfig(slotName, mimeType, slots) {
 // src/lib/qualify-with.ts
 var ALLOWED_PROPERTY_TYPES = Object.freeze([
   "text",
-  "textarea",
   "number",
   "checkbox",
   "date",
@@ -471,7 +665,6 @@ var ALLOWED_PROPERTY_TYPES = Object.freeze([
   "status",
   "select",
   "multiselect",
-  "rating",
   "location"
 ]);
 function buildPropertySchema(builders) {
@@ -511,6 +704,9 @@ function formatCheckbox(value) {
 }
 function formatNumber(value, attribute) {
   if (typeof value !== "number") return String(value);
+  if (attribute.renderAs === "rating") {
+    return `${value}/${attribute.max ?? 5}`;
+  }
   const decimals = attribute.decimals;
   if (attribute.unit === "integer") {
     return value.toLocaleString(void 0, {
@@ -558,7 +754,7 @@ function formatPhone(value) {
   if (!("phoneNumber" in phone2)) return String(value);
   if (!phone2.phoneNumber) return "";
   if (!phone2.countryCode) return phone2.phoneNumber;
-  return chunk7A3Y6O32_js.formatPhoneForDisplay(phone2);
+  return chunkEBGRZUIH_js.formatPhoneForDisplay(phone2);
 }
 function formatLocation(value, attribute) {
   if (typeof value !== "object" || value === null) return String(value);
@@ -612,18 +808,12 @@ function formatMultiselect(value, attribute) {
   }
   return value.join(", ");
 }
-function formatRating(value, attribute) {
-  if (typeof value !== "number") return String(value);
-  const max = attribute.max ?? 5;
-  return `${value}/${max}`;
-}
 function formatAttributeValue(value, attribute) {
   if (value === null || value === void 0 || value === "") {
     return EMPTY_VALUE_PLACEHOLDER;
   }
   switch (attribute.type) {
     case "text":
-    case "textarea":
       return formatText(value);
     case "checkbox":
       return formatCheckbox(value);
@@ -642,8 +832,6 @@ function formatAttributeValue(value, attribute) {
       return formatSelect(value, attribute);
     case "multiselect":
       return formatMultiselect(value, attribute);
-    case "rating":
-      return formatRating(value, attribute);
     // Unsupported types - return value as-is or placeholder
     case "file":
     case "user":
@@ -987,41 +1175,25 @@ Icon must be one of the predefined icons from @stndrds/constants.`
     );
   }
 }
-function validateOptions(options, attributeName) {
-  if (options.length === 0) return;
-  const ids = /* @__PURE__ */ new Set();
+function validateOptions(attributeName, options) {
   const values = /* @__PURE__ */ new Set();
   for (const option of options) {
-    if (!option.id?.trim()) {
-      throw new Error(
-        `[AttributeBuilder] Option in "${attributeName}" has an empty or missing id.`
-      );
-    }
     if (!option.value?.trim()) {
       throw new Error(
-        `[AttributeBuilder] Option "${option.id}" in "${attributeName}" has an empty or missing value.`
+        `[AttributeBuilder] Option in "${attributeName}" has an empty or missing value.`
       );
     }
     if (!option.label?.trim()) {
       throw new Error(
-        `[AttributeBuilder] Option "${option.id}" in "${attributeName}" has an empty or missing label.`
+        `[AttributeBuilder] Option "${option.value}" in "${attributeName}" has an empty or missing label.`
       );
     }
-    if (ids.has(option.id)) {
-      throw new Error(
-        `[AttributeBuilder] Duplicate option id "${option.id}" in "${attributeName}".`
-      );
-    }
-    ids.add(option.id);
     if (values.has(option.value)) {
       throw new Error(
         `[AttributeBuilder] Duplicate option value "${option.value}" in "${attributeName}".`
       );
     }
     values.add(option.value);
-    if (option.icon) {
-      validateIconName(option.icon, `option "${option.id}" of "${attributeName}"`);
-    }
   }
   for (const option of options) {
     if (option.inverse === void 0) continue;
@@ -1053,7 +1225,7 @@ var BaseAttributeBuilder = class {
    * @see https://standardschema.dev/
    */
   get "~standard"() {
-    const zodSchema = chunkFQ2ZYOVS_js.createAttributeValidator(this.build());
+    const zodSchema = chunkMZOEL7FN_js.createAttributeValidator(this.build());
     return createStandardSchemaProps(zodSchema);
   }
   constructor(type, name, label) {
@@ -1125,10 +1297,6 @@ var BaseAttributeBuilder = class {
     this.attr.system = false;
     return this;
   }
-  disabled() {
-    this.attr.disabled = true;
-    return this;
-  }
   hidden() {
     this.attr.hidden = true;
     return this;
@@ -1160,32 +1328,6 @@ var BaseAttributeBuilder = class {
     this.attr.metadata = value;
     return this;
   }
-  /**
-   * Add a feature gate to conditionally show/hide/disable this attribute.
-   *
-   * @param flagName - Name of the feature flag to check
-   * @param options - Optional configuration for expected value and fallback behavior
-   *
-   * @example Hide attribute when flag is disabled
-   * ```typescript
-   * text({ name: "aiSummary", label: "AI Summary" })
-   *   .featureGate("ai-features")
-   * ```
-   *
-   * @example Disable attribute when tier is not enterprise
-   * ```typescript
-   * text({ name: "advancedField", label: "Advanced Field" })
-   *   .featureGate("tier", { expectedValue: "enterprise", fallback: "disable" })
-   * ```
-   */
-  featureGate(flagName, options) {
-    this.attr.featureGate = {
-      flag: flagName,
-      expectedValue: options?.expectedValue,
-      fallback: options?.fallback
-    };
-    return this;
-  }
   build() {
     return this.attr;
   }
@@ -1206,6 +1348,10 @@ var TextAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.pattern = value;
     return this;
   }
+  multiline(value = true) {
+    this.attr.multiline = value;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this.asRequiredState();
@@ -1239,42 +1385,10 @@ var TextAttributeBuilder = class extends BaseAttributeBuilder {
 function text(config) {
   return new TextAttributeBuilder(config.name, config.label);
 }
-var TextAreaAttributeBuilder = class extends BaseAttributeBuilder {
-  constructor(name, label) {
-    super("textarea", name, label);
-  }
-  required() {
-    this.setRequired(true);
-    return this.asRequiredState();
-  }
-  optional() {
-    this.setRequired(false);
-    return this.asRequiredState();
-  }
-};
-function textarea(config) {
-  return new TextAreaAttributeBuilder(config.name, config.label);
-}
 var RichtextAttributeBuilder = class extends BaseAttributeBuilder {
   constructor(name, label) {
     super("richtext", name, label);
   }
-  /**
-   * Set enabled features for the richtext editor
-   * If not called, all features are enabled by default
-   *
-   * @param list - Array of features to enable
-   *
-   * @example
-   * ```typescript
-   * richtext({ name: "content", label: "Content" })
-   *   .features(["headings", "bold", "italic", "lists", "links"])
-   * ```
-   */
-  features(list) {
-    this.attr.features = list;
-    return this;
-  }
   required() {
     this.setRequired(true);
     return this.asRequiredState();
@@ -1313,6 +1427,10 @@ var NumberAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.unit = "percentage";
     return this;
   }
+  renderAs(value) {
+    this.attr.renderAs = value;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this.asRequiredState();
@@ -1426,7 +1544,7 @@ var StatusAttributeBuilder = class extends BaseAttributeBuilder {
    */
   options(value) {
     const mutableOptions = asMutableArray(value);
-    validateOptions(mutableOptions, this.attr.name ?? "unknown");
+    validateOptions(this.attr.name ?? "unknown", mutableOptions);
     this.attr.options = mutableOptions;
     return this.asPhantomState();
   }
@@ -1435,7 +1553,7 @@ var StatusAttributeBuilder = class extends BaseAttributeBuilder {
       this.attr.options = [];
     }
     const allOptions = [...this.attr.options, config];
-    validateOptions(allOptions, this.attr.name ?? "unknown");
+    validateOptions(this.attr.name ?? "unknown", allOptions);
     this.attr.options.push(config);
     return this;
   }
@@ -1460,7 +1578,7 @@ var SelectAttributeBuilder = class extends BaseAttributeBuilder {
    */
   options(value) {
     const mutableOptions = asMutableArray(value);
-    validateOptions(mutableOptions, this.attr.name ?? "unknown");
+    validateOptions(this.attr.name ?? "unknown", mutableOptions);
     this.attr.options = mutableOptions;
     return this.asPhantomState();
   }
@@ -1469,7 +1587,7 @@ var SelectAttributeBuilder = class extends BaseAttributeBuilder {
       this.attr.options = [];
     }
     const allOptions = [...this.attr.options, config];
-    validateOptions(allOptions, this.attr.name ?? "unknown");
+    validateOptions(this.attr.name ?? "unknown", allOptions);
     this.attr.options.push(config);
     return this;
   }
@@ -1494,7 +1612,7 @@ var MultiselectAttributeBuilder = class extends BaseAttributeBuilder {
    */
   options(value) {
     const mutableOptions = asMutableArray(value);
-    validateOptions(mutableOptions, this.attr.name ?? "unknown");
+    validateOptions(this.attr.name ?? "unknown", mutableOptions);
     this.attr.options = mutableOptions;
     return this.asPhantomState();
   }
@@ -1503,7 +1621,7 @@ var MultiselectAttributeBuilder = class extends BaseAttributeBuilder {
       this.attr.options = [];
     }
     const allOptions = [...this.attr.options, config];
-    validateOptions(allOptions, this.attr.name ?? "unknown");
+    validateOptions(this.attr.name ?? "unknown", allOptions);
     this.attr.options.push(config);
     return this;
   }
@@ -1527,14 +1645,6 @@ var LocationAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.granularity = value;
     return this;
   }
-  enableAutocomplete() {
-    this.attr.enableAutocomplete = true;
-    return this;
-  }
-  enableMap() {
-    this.attr.enableMap = true;
-    return this;
-  }
   defaultCountry(value) {
     this.attr.defaultCountry = value;
     return this;
@@ -1543,10 +1653,6 @@ var LocationAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.allowedCountries = value;
     return this;
   }
-  displayFormat(value) {
-    this.attr.displayFormat = value;
-    return this;
-  }
   required() {
     this.setRequired(true);
     return this.asRequiredState();
@@ -1597,9 +1703,14 @@ function file(config) {
 var UserAttributeBuilder = class extends BaseAttributeBuilder {
   constructor(name, label) {
     super("user", name, label);
+    this.attr.types = ["user", "agent"];
   }
-  allowedRoles(roles) {
-    this.attr.allowedRoles = roles;
+  types(types) {
+    const unique = [...new Set(types)];
+    if (unique.length === 0) {
+      throw new Error("[AttributeBuilder] user.types must contain at least one type.");
+    }
+    this.attr.types = unique;
     return this;
   }
   /**
@@ -1710,18 +1821,11 @@ var SingleRelationAttributeBuilder = class extends BaseRelationAttributeBuilder
     );
     if (this.attr.system === false) multiBuilder.runtime();
     if (this.attr.hidden) multiBuilder.hidden();
-    if (this.attr.disabled) multiBuilder.disabled();
     if (this.attr.placeholder) multiBuilder.placeholder(this.attr.placeholder);
     if (this.attr.description) multiBuilder.description(this.attr.description);
     if (this.attr.icon) multiBuilder.icon(this.attr.icon);
     if (this.attr.order !== void 0) multiBuilder.order(this.attr.order);
     if (this.attr.metadata) multiBuilder.metadata(this.attr.metadata);
-    if (this.attr.featureGate) {
-      multiBuilder.featureGate(this.attr.featureGate.flag, {
-        expectedValue: this.attr.featureGate.expectedValue,
-        fallback: this.attr.featureGate.fallback
-      });
-    }
     return multiBuilder;
   }
   required() {
@@ -1743,13 +1847,6 @@ var MultiRelationAttributeBuilder = class extends BaseRelationAttributeBuilder {
       this.setRequired(true);
     }
   }
-  /**
-   * Set minimum number of relations required
-   */
-  minItems(count) {
-    this.attr.minItems = count;
-    return this;
-  }
   /**
    * Set maximum number of relations allowed
    */
@@ -1769,30 +1866,6 @@ var MultiRelationAttributeBuilder = class extends BaseRelationAttributeBuilder {
 function relation(config) {
   return new SingleRelationAttributeBuilder(config.name, config.label);
 }
-var RatingAttributeBuilder = class extends BaseAttributeBuilder {
-  constructor(name, label) {
-    super("rating", name, label);
-  }
-  max(value) {
-    this.attr.max = value;
-    return this;
-  }
-  iconType(value) {
-    this.attr.iconType = value;
-    return this;
-  }
-  required() {
-    this.setRequired(true);
-    return this.asRequiredState();
-  }
-  optional() {
-    this.setRequired(false);
-    return this.asRequiredState();
-  }
-};
-function rating(config) {
-  return new RatingAttributeBuilder(config.name, config.label);
-}
 var FormulaAttributeBuilder = class extends BaseAttributeBuilder {
   constructor(name, label) {
     super("formula", name, label);
@@ -1916,20 +1989,6 @@ var DocumentAttributeBuilder = class extends BaseAttributeBuilder {
   constructor(name, label) {
     super("document", name, label);
   }
-  /**
-   * Maximum number of documents.
-   */
-  maxDocuments(count) {
-    this.attr.maxDocuments = count;
-    return this;
-  }
-  /**
-   * Automatically trigger agent-compatible processing on upload.
-   */
-  autoProcess() {
-    this.attr.autoProcess = true;
-    return this;
-  }
   /**
    * Define named upload slots for this document attribute.
    * An empty array falls back to a single default slot.
@@ -1938,38 +1997,6 @@ var DocumentAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.slots = configs.length === 0 ? [DEFAULT_DOCUMENT_SLOT] : configs;
     return this;
   }
-  /**
-   * Add a child attribute that qualifies the record→document edge.
-   *
-   * Equivalent to `.qualifyWith(builder)` for a single attribute, with the
-   * difference that the accepted type is broader (`Attribute`) and the
-   * accumulation is mutating rather than type-tracking. When the produced
-   * attribute is one of the `ALLOWED_PROPERTY_TYPES`, it is also pushed
-   * onto `attribute.properties.definitions`, so hydration and validation
-   * treat the document as qualified — same effect as `.qualifyWith()`.
-   *
-   * Both `attribute.attributes` and `attribute.properties` are populated to
-   * keep backwards compatibility with consumers that read either field.
-   *
-   * @example
-   * document({ name: "invoices" })
-   *   .attribute(date({ name: "invoiceDate", label: "Date" }).required())
-   *   .attribute(select({ name: "status", label: "Statut" }).options([...]))
-   */
-  attribute(builder) {
-    const built = builder.build();
-    if (!this.attr.attributes) this.attr.attributes = [];
-    this.attr.attributes = [...this.attr.attributes, built];
-    if (ALLOWED_PROPERTY_TYPES.includes(built.type)) {
-      const props = this.attr.properties ?? {
-        definitions: []
-      };
-      this.attr.properties = {
-        definitions: [...props.definitions, built]
-      };
-    }
-    return this;
-  }
   /**
    * Add properties to qualify each document using existing attribute builders.
    * Returns a new builder type that carries the inferred props shape for $infer.
@@ -2305,11 +2332,9 @@ function form(name, label) {
 function resolveBuiltInTransform(targetType) {
   const map = {
     text: "toString",
-    textarea: "toString",
     richtext: "toString",
     number: "toNumber",
     currency: "toNumber",
-    rating: "toNumber",
     date: "toDate",
     checkbox: "toBoolean"
   };
@@ -2414,6 +2439,8 @@ var MigrationBuilder = class {
 var ObjectBuilder = class {
   constructor(config) {
     this._migrations = [];
+    this._sealed = false;
+    this._toleratedAttributes = [];
     this.validateName(config.name);
     this.obj = {
       name: config.name,
@@ -2431,7 +2458,7 @@ var ObjectBuilder = class {
    * @see https://standardschema.dev/
    */
   get "~standard"() {
-    const zodSchema = chunkFQ2ZYOVS_js.createObjectValidator(this.build());
+    const zodSchema = chunkMZOEL7FN_js.createObjectValidator(this.build());
     return createStandardSchemaProps(zodSchema);
   }
   /**
@@ -2474,6 +2501,43 @@ var ObjectBuilder = class {
     this.obj.system = false;
     return this;
   }
+  /**
+   * Marks this object as sealed — no custom (user-created) attributes allowed.
+   *
+   * When sealed, `standards diff` reports an error if any custom attribute
+   * exists in the DB that is not listed in `.tolerate()`.
+   *
+   * @example
+   * ```typescript
+   * object({ name: "invoice", label: "Invoice" })
+   *   .sealed()
+   *   .attribute(number({ name: "amount", label: "Amount" }))
+   * ```
+   */
+  sealed() {
+    this._sealed = true;
+    return this;
+  }
+  /**
+   * Explicitly acknowledges custom attribute names on this object.
+   *
+   * On a sealed object: listed names will NOT trigger a CI failure in `standards diff`.
+   * On an extensible object: purely documentary.
+   *
+   * @param names - Array of custom attribute names to tolerate
+   *
+   * @example
+   * ```typescript
+   * object({ name: "invoice", label: "Invoice" })
+   *   .sealed()
+   *   .tolerate(["legacy_ref", "old_status"])
+   *   .attribute(number({ name: "amount", label: "Amount" }))
+   * ```
+   */
+  tolerate(names) {
+    this._toleratedAttributes = [...this._toleratedAttributes, ...names];
+    return this;
+  }
   /**
    * Add an attribute to the object with type accumulation
    *
@@ -2598,17 +2662,17 @@ var ObjectBuilder = class {
       throw new Error("[ObjectBuilder] Missing required field: label");
     }
     if (!this._labelExpression) {
-      throw new chunkFQ2ZYOVS_js.SchemaError(
+      throw new chunkMZOEL7FN_js.SchemaError(
         `Object "${this.obj.name}" must have a labelExpression. The labelExpression defines how records are displayed in lists and relations (e.g. "{{ name }}").`,
-        chunkFQ2ZYOVS_js.SchemaErrorCode.VALIDATION_FAILED
+        chunkMZOEL7FN_js.SchemaErrorCode.VALIDATION_FAILED
       );
     }
     const labelResult = labelExpressionSchema.safeParse(this._labelExpression);
     if (!labelResult.success) {
       const errorMsg = labelResult.error.issues[0]?.message ?? "Invalid labelExpression";
-      throw new chunkFQ2ZYOVS_js.SchemaError(
+      throw new chunkMZOEL7FN_js.SchemaError(
         `Invalid labelExpression for "${this.obj.name}": ${errorMsg}`,
-        chunkFQ2ZYOVS_js.SchemaErrorCode.VALIDATION_FAILED
+        chunkMZOEL7FN_js.SchemaErrorCode.VALIDATION_FAILED
       );
     }
     const sortedVersions = [...this._migrations].sort((a, b) => a.version - b.version);
@@ -2626,7 +2690,9 @@ var ObjectBuilder = class {
       pluralLabel: this._pluralLabel,
       labelExpression: this._labelExpression,
       schema_version,
-      migrations: sortedVersions
+      migrations: sortedVersions,
+      sealed: this._sealed,
+      toleratedAttributes: this._toleratedAttributes
     };
   }
   /**
@@ -2645,7 +2711,7 @@ var ObjectBuilder = class {
       objectNameSchema.parse(name);
     } catch (error) {
       if (error instanceof z3__default.default.ZodError) {
-        throw new chunkFQ2ZYOVS_js.SchemaError(error.issues[0].message, chunkFQ2ZYOVS_js.SchemaErrorCode.INVALID_OBJECT_NAME);
+        throw new chunkMZOEL7FN_js.SchemaError(error.issues[0].message, chunkMZOEL7FN_js.SchemaErrorCode.INVALID_OBJECT_NAME);
       }
       throw error;
     }
@@ -4515,9 +4581,9 @@ Available views: ${availableNames}`
 var viewRegistry = new ViewRegistry();
 
 // src/views/auto-generator.ts
-function getVisibleAttributes(attributes, excludeNames = []) {
+function getRuntimeAttributes(attributes, excludeNames = []) {
   return attributes.filter(
-    (attr) => !(attr.hidden || attr.archived || attr.system || excludeNames.includes(attr.name))
+    (attr) => !(!getAttributeCapabilities(attr).lifecycle.visibleInRuntime || attr.system || excludeNames.includes(attr.name))
   );
 }
 function sortAttributes(attributes) {
@@ -4528,9 +4594,9 @@ function sortAttributes(attributes) {
     return a.name.localeCompare(b.name);
   });
 }
-function getDefaultFieldSpan(type) {
-  switch (type) {
-    case "textarea":
+function getDefaultFieldSpan(attr) {
+  if (attr.type === "text" && attr.multiline) return 12;
+  switch (attr.type) {
     case "richtext":
     case "location":
       return 12;
@@ -4543,7 +4609,7 @@ function getDefaultFieldSpan(type) {
 function attributeToField(attr) {
   return {
     attribute: attr.name,
-    span: getDefaultFieldSpan(attr.type)
+    span: getDefaultFieldSpan(attr)
   };
 }
 function generateDefaultDetailView(object2, options = {}) {
@@ -4553,8 +4619,10 @@ function generateDefaultDetailView(object2, options = {}) {
     excludeAttributes = [],
     layout = "page"
   } = options;
-  const visibleAttrs = getVisibleAttributes(object2.attributes, excludeAttributes);
-  const sortedAttrs = sortAttributes(visibleAttrs);
+  const runtimeAttrs = getRuntimeAttributes(object2.attributes, excludeAttributes);
+  const sortedAttrs = sortAttributes(
+    runtimeAttrs.filter((attr) => getAttributeCapabilities(attr).presentation.formField)
+  );
   const formTab = {
     id: "form",
     name: "form",
@@ -4609,8 +4677,10 @@ function generateDefaultDetailView(object2, options = {}) {
 }
 function generateDefaultListView(object2, options = {}) {
   const { excludeAttributes = [], maxListColumns = 5 } = options;
-  const visibleAttrs = getVisibleAttributes(object2.attributes, excludeAttributes);
-  const sortedAttrs = sortAttributes(visibleAttrs);
+  const runtimeAttrs = getRuntimeAttributes(object2.attributes, excludeAttributes);
+  const sortedAttrs = sortAttributes(
+    runtimeAttrs.filter((attr) => getAttributeCapabilities(attr).presentation.defaultColumn)
+  );
   const columns = sortedAttrs.slice(0, maxListColumns).map((attr) => attr.name);
   const config = {
     tabs: [
@@ -4652,289 +4722,1709 @@ function mergeDetailTabs(generatedTabs, preservedTabs) {
   if (preservedTabs.length === 0) {
     return generatedTabs;
   }
-  const formTab = generatedTabs.find((t) => t.type === "form");
-  const otherTabs = generatedTabs.filter((t) => t.type !== "form");
-  const result = [];
-  if (formTab) {
-    result.push(formTab);
+  const formTab = generatedTabs.find((t) => t.type === "form");
+  const otherTabs = generatedTabs.filter((t) => t.type !== "form");
+  const result = [];
+  if (formTab) {
+    result.push(formTab);
+  }
+  let order = 1;
+  for (const tab of preservedTabs) {
+    result.push({ ...tab, order: order++ });
+  }
+  for (const tab of otherTabs) {
+    result.push({ ...tab, order: order++ });
+  }
+  return result;
+}
+function resetDetailViewToDefault(view, object2, options) {
+  const { preserveMetadata = true, ...generateOptions } = options;
+  const defaultView = generateDefaultDetailView(object2, generateOptions);
+  const preservedTabs = getPreservedDetailTabs(view, options);
+  const mergedTabs = mergeDetailTabs(defaultView.config.tabs, preservedTabs);
+  const config = {
+    ...defaultView.config,
+    tabs: mergedTabs
+  };
+  const resetView = {
+    ...defaultView,
+    config
+  };
+  if (preserveMetadata) {
+    resetView.id = view.id;
+    resetView.name = view.name;
+    resetView.label = view.label;
+    resetView.description = view.description;
+    resetView.icon = view.icon;
+  }
+  return resetView;
+}
+function resetListViewToDefault(view, object2, options) {
+  const { preserveMetadata = true, ...generateOptions } = options;
+  const defaultView = generateDefaultListView(object2, generateOptions);
+  const resetView = {
+    ...defaultView
+  };
+  if (preserveMetadata) {
+    resetView.id = view.id;
+    resetView.name = view.name;
+    resetView.label = view.label;
+    resetView.description = view.description;
+    resetView.icon = view.icon;
+  }
+  return resetView;
+}
+function resetViewToDefault(currentView, object2, options = {}) {
+  if (isDetailView(currentView)) {
+    return resetDetailViewToDefault(currentView, object2, options);
+  }
+  if (isListView(currentView)) {
+    return resetListViewToDefault(currentView, object2, options);
+  }
+  throw new Error(`Reset not supported for view type: ${currentView.type}`);
+}
+
+// src/views/index.ts
+function getActiveTab(config, tabId) {
+  if (tabId) {
+    const tab = config.tabs.find((t) => t.id === tabId);
+    if (tab) return tab;
+  }
+  return config.tabs.find((t) => t.default) ?? config.tabs[0];
+}
+
+// src/forms/registry.ts
+var FormRegistry = class {
+  constructor() {
+    this.forms = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register a form definition (or array of definitions).
+   * @throws Error if a form with the same name is already registered.
+   */
+  register(formOrForms) {
+    const forms = Array.isArray(formOrForms) ? formOrForms : [formOrForms];
+    for (const f of forms) {
+      if (this.forms.has(f.name)) {
+        throw new Error(`[FormRegistry] Duplicate form: "${f.name}"`);
+      }
+      this.forms.set(f.name, f);
+    }
+    return this;
+  }
+  /**
+   * Get a form definition by name.
+   */
+  get(name) {
+    return this.forms.get(name);
+  }
+  /**
+   * Get all registered form definitions.
+   */
+  getAll() {
+    return Array.from(this.forms.values());
+  }
+  /**
+   * List all registered form names.
+   */
+  listNames() {
+    return Array.from(this.forms.keys());
+  }
+};
+var formRegistry = new FormRegistry();
+
+// src/realtime/channels.ts
+function liveChannelKey(channel) {
+  switch (channel.kind) {
+    case "workspace":
+      return `workspace:${encodeURIComponent(channel.workspaceId)}`;
+    case "object":
+      return `object:${encodeURIComponent(channel.objectId)}`;
+    case "record":
+      return `record:${encodeURIComponent(channel.objectId)}:${encodeURIComponent(channel.recordId)}`;
+    case "view":
+      return `view:${encodeURIComponent(channel.viewId)}`;
+    case "agent":
+      return `agent:${encodeURIComponent(channel.workspaceId)}`;
+    case "user":
+      return `user:${encodeURIComponent(channel.actorId)}`;
+    case "conversation":
+      return `conversation:${encodeURIComponent(channel.sessionId)}`;
+  }
+}
+function decodeLiveChannelPart(part) {
+  try {
+    return decodeURIComponent(part);
+  } catch {
+    return null;
+  }
+}
+function parseLiveChannelKey(key) {
+  const parts = key.split(":");
+  if (parts[0] === "workspace" && parts.length === 2 && parts[1]) {
+    const workspaceId = decodeLiveChannelPart(parts[1]);
+    return workspaceId ? { kind: "workspace", workspaceId } : null;
+  }
+  if (parts[0] === "object" && parts.length === 2 && parts[1]) {
+    const objectId = decodeLiveChannelPart(parts[1]);
+    return objectId ? { kind: "object", objectId } : null;
+  }
+  if (parts[0] === "record" && parts.length === 3 && parts[1] && parts[2]) {
+    const objectId = decodeLiveChannelPart(parts[1]);
+    const recordId = decodeLiveChannelPart(parts[2]);
+    if (!(objectId && recordId)) return null;
+    return {
+      kind: "record",
+      objectId,
+      recordId
+    };
+  }
+  if (parts[0] === "view" && parts.length === 2 && parts[1]) {
+    const viewId = decodeLiveChannelPart(parts[1]);
+    return viewId ? { kind: "view", viewId } : null;
+  }
+  if (parts[0] === "agent" && parts.length === 2 && parts[1]) {
+    const workspaceId = decodeLiveChannelPart(parts[1]);
+    return workspaceId ? { kind: "agent", workspaceId } : null;
+  }
+  if (parts[0] === "user" && parts.length === 2 && parts[1]) {
+    const actorId = decodeLiveChannelPart(parts[1]);
+    return actorId ? { kind: "user", actorId } : null;
+  }
+  if (parts[0] === "conversation" && parts.length === 2 && parts[1]) {
+    const sessionId = decodeLiveChannelPart(parts[1]);
+    return sessionId ? { kind: "conversation", sessionId } : null;
+  }
+  return null;
+}
+
+// src/realtime/cursors.ts
+var LIVE_STREAM_START_CURSOR = "0-0";
+var LIVE_STREAM_CURSOR_PATTERN = /^(0|[1-9]\d*)-(0|[1-9]\d*)$/;
+function parseLiveStreamCursor(cursor) {
+  if (!LIVE_STREAM_CURSOR_PATTERN.test(cursor)) {
+    return null;
+  }
+  const [milliseconds = "0", sequence = "0"] = cursor.split("-");
+  return [BigInt(milliseconds), BigInt(sequence)];
+}
+function isLiveStreamCursor(value) {
+  return typeof value === "string" && parseLiveStreamCursor(value) !== null;
+}
+function assertLiveStreamCursor(cursor, label = "cursor") {
+  if (cursor === null) {
+    return;
+  }
+  if (!isLiveStreamCursor(cursor)) {
+    throw new Error(`Invalid live stream cursor for ${label}: ${cursor}`);
+  }
+}
+function compareLiveStreamCursors(left, right) {
+  const leftCursor = parseLiveStreamCursor(left);
+  if (!leftCursor) {
+    throw new Error(`Invalid live stream cursor for left: ${left}`);
+  }
+  const rightCursor = parseLiveStreamCursor(right);
+  if (!rightCursor) {
+    throw new Error(`Invalid live stream cursor for right: ${right}`);
+  }
+  const [leftMilliseconds, leftSequence] = leftCursor;
+  const [rightMilliseconds, rightSequence] = rightCursor;
+  if (leftMilliseconds !== rightMilliseconds) {
+    return leftMilliseconds < rightMilliseconds ? -1 : 1;
+  }
+  if (leftSequence !== rightSequence) {
+    return leftSequence < rightSequence ? -1 : 1;
+  }
+  return 0;
+}
+
+// src/realtime/events.ts
+var LIVE_EVENT_TYPE_REGISTRY = {
+  "record.patch": true,
+  "record.deleted": true,
+  "view.projection.stale": true,
+  "agent.session.patch": true,
+  "agent.unread.patch": true,
+  "conversation.renamed": true,
+  "channel.revoked": true
+};
+var LIVE_EVENT_TYPES = Object.keys(LIVE_EVENT_TYPE_REGISTRY);
+var COMPLETION_STATUSES = ["draft", "complete"];
+var VIEW_PROJECTION_STALE_REASONS = [
+  "membership-unknown",
+  "sort-unknown",
+  "permissions-changed"
+];
+var CHANNEL_REVOKED_REASONS = [
+  "permission-revoked",
+  "workspace-left",
+  "object-deleted"
+];
+function isLiveEventType(value) {
+  return typeof value === "string" && LIVE_EVENT_TYPES.includes(value);
+}
+function isLiveEventPayload(payload) {
+  if (!(isRecord(payload) && isLiveEventType(payload.type))) {
+    return false;
+  }
+  return isLiveEventPayloadForType(payload.type, payload);
+}
+function isLiveEventPayloadForType(type, payload) {
+  if (!isRecord(payload)) {
+    return false;
+  }
+  switch (type) {
+    case "record.patch":
+      return isRecordPatchPayload(payload);
+    case "record.deleted":
+      return isRecordDeletedPayload(payload);
+    case "view.projection.stale":
+      return isViewProjectionStalePayload(payload);
+    case "agent.session.patch":
+      return isAgentSessionPatchPayload(payload);
+    case "agent.unread.patch":
+      return isAgentUnreadPatchPayload(payload);
+    case "conversation.renamed":
+      return isConversationRenamedPayload(payload);
+    case "channel.revoked":
+      return isChannelRevokedPayload(payload);
+    default:
+      return false;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isVersion(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function hasString(value, key) {
+  return isString(value[key]);
+}
+function hasVersion(value, key) {
+  return isVersion(value[key]);
+}
+function hasOptional(value, key, predicate) {
+  return !Object.hasOwn(value, key) || predicate(value[key]);
+}
+function isOneOf(value, values) {
+  return typeof value === "string" && values.includes(value);
+}
+function isCompletionStatus(value) {
+  return isOneOf(value, COMPLETION_STATUSES);
+}
+function isRecordFieldPatch(value) {
+  return isRecord(value) && hasString(value, "fieldKey") && Object.hasOwn(value, "value") && hasVersion(value, "version");
+}
+function isRecordPatchPayload(payload) {
+  return payload.type === "record.patch" && hasString(payload, "objectId") && hasString(payload, "recordId") && hasVersion(payload, "recordVersion") && hasOptional(payload, "label", isString) && hasOptional(payload, "completionStatus", isCompletionStatus) && hasOptional(payload, "metadata", isRecord) && Array.isArray(payload.fieldPatches) && payload.fieldPatches.every(isRecordFieldPatch) && hasString(payload, "updatedAt");
+}
+function isRecordDeletedPayload(payload) {
+  return payload.type === "record.deleted" && hasString(payload, "objectId") && hasString(payload, "recordId") && hasVersion(payload, "recordVersion") && hasString(payload, "deletedAt");
+}
+function isViewProjectionStalePayload(payload) {
+  return payload.type === "view.projection.stale" && hasString(payload, "viewId") && isOneOf(payload.reason, VIEW_PROJECTION_STALE_REASONS);
+}
+function isAgentSessionPatchPayload(payload) {
+  return payload.type === "agent.session.patch" && hasString(payload, "workspaceId") && hasString(payload, "sessionId") && isRecord(payload.patch) && hasVersion(payload, "version") && hasString(payload, "updatedAt");
+}
+function isAgentUnreadPatchPayload(payload) {
+  return payload.type === "agent.unread.patch" && hasString(payload, "workspaceId") && hasString(payload, "targetActorId") && hasString(payload, "sessionId") && hasVersion(payload, "unreadCount") && hasVersion(payload, "version") && hasString(payload, "updatedAt") && (!Object.hasOwn(payload, "session") || isRecord(payload.session) && payload.session.id === payload.sessionId);
+}
+function isConversationRenamedPayload(payload) {
+  return payload.type === "conversation.renamed" && hasString(payload, "workspaceId") && hasString(payload, "sessionId") && hasString(payload, "title") && hasVersion(payload, "version") && hasString(payload, "updatedAt");
+}
+function isChannelRevokedPayload(payload) {
+  return payload.type === "channel.revoked" && hasString(payload, "channel") && isOneOf(payload.reason, CHANNEL_REVOKED_REASONS);
+}
+
+// src/realtime/protocol.ts
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function payloadChannel(payload) {
+  const { channel } = payload;
+  return typeof channel === "string" && parseLiveChannelKey(channel) ? channel : null;
+}
+function getLiveProtocolPayloadChannel(payload) {
+  return isRecord2(payload) ? payloadChannel(payload) : null;
+}
+function isLiveEventEnvelope(payload) {
+  if (!isRecord2(payload)) return false;
+  return typeof payload.id === "string" && isLiveStreamCursor(payload.id) && typeof payload.channel === "string" && typeof payload.type === "string" && typeof payload.occurredAt === "string" && isRecord2(payload.payload);
+}
+function parseLiveSubscribePayload(payload) {
+  if (!isRecord2(payload)) return null;
+  const channel = payloadChannel(payload);
+  if (!channel) return null;
+  const { cursor } = payload;
+  if (cursor !== void 0 && cursor !== null) {
+    if (typeof cursor !== "string" || !isLiveStreamCursor(cursor)) {
+      return null;
+    }
+  }
+  return { channel, cursor: cursor ?? null };
+}
+function parseLiveUnsubscribePayload(payload) {
+  if (payload === void 0 || payload === null) return {};
+  if (!isRecord2(payload)) return null;
+  if (!Object.hasOwn(payload, "channel")) {
+    return {};
+  }
+  const channel = payloadChannel(payload);
+  return channel ? { channel } : null;
+}
+function isLiveReplayCompletePayload(payload) {
+  if (!isRecord2(payload)) return false;
+  const channel = payloadChannel(payload);
+  if (!channel) return false;
+  return payload.cursor === null || typeof payload.cursor === "string" && isLiveStreamCursor(payload.cursor);
+}
+function isLiveGapPayload(payload) {
+  if (!isRecord2(payload)) return false;
+  return payloadChannel(payload) !== null;
+}
+function isLiveErrorPayload(payload) {
+  if (!isRecord2(payload)) return false;
+  return payloadChannel(payload) !== null;
+}
+
+// src/computed/functions.ts
+var COMPUTED_FUNCTION_NAMES = [
+  "if",
+  "concat",
+  "sum",
+  "avg",
+  "count",
+  "min",
+  "max",
+  "earliest",
+  "latest",
+  "unique",
+  "first",
+  "percent_empty",
+  "percent_not_empty",
+  "count_empty",
+  "count_not_empty",
+  "count_unique"
+];
+var COMPUTED_FUNCTIONS = {
+  if: { name: "if", returnType: "branch", minArgs: 3, maxArgs: 3 },
+  concat: { name: "concat", returnType: { kind: "scalar", type: "text" }, minArgs: 1 },
+  sum: { name: "sum", returnType: { kind: "scalar", type: "number" }, minArgs: 1, maxArgs: 1 },
+  avg: { name: "avg", returnType: { kind: "scalar", type: "number" }, minArgs: 1, maxArgs: 1 },
+  count: { name: "count", returnType: { kind: "scalar", type: "number" }, minArgs: 1, maxArgs: 1 },
+  min: { name: "min", returnType: "source_item", minArgs: 1, maxArgs: 1 },
+  max: { name: "max", returnType: "source_item", minArgs: 1, maxArgs: 1 },
+  earliest: {
+    name: "earliest",
+    returnType: { kind: "scalar", type: "date" },
+    minArgs: 1,
+    maxArgs: 1
+  },
+  latest: { name: "latest", returnType: { kind: "scalar", type: "date" }, minArgs: 1, maxArgs: 1 },
+  unique: { name: "unique", returnType: "argument", minArgs: 1, maxArgs: 1 },
+  first: { name: "first", returnType: "source_item", minArgs: 1, maxArgs: 1 },
+  percent_empty: {
+    name: "percent_empty",
+    returnType: { kind: "scalar", type: "number" },
+    minArgs: 1,
+    maxArgs: 1
+  },
+  percent_not_empty: {
+    name: "percent_not_empty",
+    returnType: { kind: "scalar", type: "number" },
+    minArgs: 1,
+    maxArgs: 1
+  },
+  count_empty: {
+    name: "count_empty",
+    returnType: { kind: "scalar", type: "number" },
+    minArgs: 1,
+    maxArgs: 1
+  },
+  count_not_empty: {
+    name: "count_not_empty",
+    returnType: { kind: "scalar", type: "number" },
+    minArgs: 1,
+    maxArgs: 1
+  },
+  count_unique: {
+    name: "count_unique",
+    returnType: { kind: "scalar", type: "number" },
+    minArgs: 1,
+    maxArgs: 1
+  }
+};
+function isComputedFunctionName(name) {
+  return Object.hasOwn(COMPUTED_FUNCTIONS, name);
+}
+
+// src/computed/parser.ts
+var ComputedFormulaParseError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComputedFormulaParseError";
+  }
+};
+function parseComputedFormula(expression) {
+  const parser = new Parser(tokenize(expression));
+  const ast = parser.parseExpression();
+  parser.expectEnd();
+  return ast;
+}
+function tokenize(expression) {
+  const tokens = [];
+  let index = 0;
+  while (index < expression.length) {
+    const char = expression[index];
+    if (char === " " || char === "	" || char === "\n" || char === "\r") {
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const result = scanString(expression, index, char);
+      tokens.push({ kind: "string", value: result.value, position: index });
+      index = result.nextIndex;
+      continue;
+    }
+    if (isDigit(char)) {
+      const result = scanNumber(expression, index);
+      tokens.push({ kind: "number", value: result.value, position: index });
+      index = result.nextIndex;
+      continue;
+    }
+    if (isIdentifierStart(char)) {
+      const result = scanIdentifier(expression, index);
+      const canonical = result.value.toLowerCase();
+      if (canonical === "true") {
+        tokens.push({ kind: "boolean", value: true, position: index });
+      } else if (canonical === "false") {
+        tokens.push({ kind: "boolean", value: false, position: index });
+      } else if (canonical === "null") {
+        tokens.push({ kind: "null", position: index });
+      } else {
+        tokens.push({ kind: "identifier", value: result.value, position: index });
+      }
+      index = result.nextIndex;
+      continue;
+    }
+    const twoChar = expression.slice(index, index + 2);
+    if (twoChar === ">=" || twoChar === "<=" || twoChar === "==" || twoChar === "!=") {
+      tokens.push({ kind: "operator", value: twoChar, position: index });
+      index += 2;
+      continue;
+    }
+    if (char === ">" || char === "<" || char === "+" || char === "-" || char === "*" || char === "/") {
+      tokens.push({ kind: "operator", value: char, position: index });
+      index += 1;
+      continue;
+    }
+    if (char === "(" || char === ")" || char === "," || char === ".") {
+      tokens.push({ kind: "punctuation", value: char, position: index });
+      index += 1;
+      continue;
+    }
+    throw new ComputedFormulaParseError(`Unexpected character "${char}" at position ${index}`);
+  }
+  return tokens;
+}
+function scanString(expression, startIndex, delimiter = '"') {
+  let value = "";
+  let index = startIndex + 1;
+  while (index < expression.length) {
+    const char = expression[index];
+    if (char === delimiter) {
+      return { value, nextIndex: index + 1 };
+    }
+    if (char === "\\") {
+      const escaped = expression[index + 1];
+      if (escaped === void 0) {
+        throw new ComputedFormulaParseError(`Unterminated string literal at position ${index}`);
+      }
+      value += decodeEscape(escaped, index);
+      index += 2;
+      continue;
+    }
+    value += char;
+    index += 1;
+  }
+  throw new ComputedFormulaParseError(`Unterminated string literal at position ${startIndex}`);
+}
+function decodeEscape(char, position) {
+  switch (char) {
+    case '"':
+    case "\\":
+      return char;
+    case "n":
+      return "\n";
+    case "r":
+      return "\r";
+    case "t":
+      return "	";
+    default:
+      throw new ComputedFormulaParseError(
+        `Unknown escape sequence "\\${char}" at position ${position}`
+      );
+  }
+}
+function scanNumber(expression, startIndex) {
+  let index = startIndex;
+  while (index < expression.length && isDigit(expression[index])) {
+    index += 1;
+  }
+  if (expression[index] === ".") {
+    const decimalStart = index;
+    index += 1;
+    if (!isDigit(expression[index])) {
+      throw new ComputedFormulaParseError(`Invalid number literal at position ${decimalStart}`);
+    }
+    while (index < expression.length && isDigit(expression[index])) {
+      index += 1;
+    }
+  }
+  const raw = expression.slice(startIndex, index);
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new ComputedFormulaParseError(`Invalid number literal "${raw}"`);
+  }
+  return { value, nextIndex: index };
+}
+function scanIdentifier(expression, startIndex) {
+  let index = startIndex + 1;
+  while (index < expression.length && isIdentifierPart(expression[index])) {
+    index += 1;
+  }
+  return { value: expression.slice(startIndex, index), nextIndex: index };
+}
+function isDigit(char) {
+  return char !== void 0 && char >= "0" && char <= "9";
+}
+function isIdentifierStart(char) {
+  return char !== void 0 && /[A-Za-z_]/.test(char);
+}
+function isIdentifierPart(char) {
+  return char !== void 0 && /[A-Za-z0-9_]/.test(char);
+}
+var Parser = class {
+  constructor(tokens) {
+    this.tokens = tokens;
+    this.position = 0;
+  }
+  parseExpression() {
+    return this.parseBinaryExpression(0);
+  }
+  expectEnd() {
+    const token = this.peek();
+    if (token !== void 0) {
+      throw new ComputedFormulaParseError(
+        `Unexpected token ${describeToken(token)} at position ${token.position}`
+      );
+    }
+  }
+  parseBinaryExpression(minPrecedence) {
+    let left = this.parsePrimary();
+    while (true) {
+      const token = this.peek();
+      if (token?.kind !== "operator") {
+        return left;
+      }
+      const precedence = getOperatorPrecedence(token.value);
+      if (precedence < minPrecedence) {
+        return left;
+      }
+      const operator = token.value;
+      this.consume();
+      const right = this.parseBinaryExpression(precedence + 1);
+      left = { kind: "binary", operator, left, right };
+    }
+  }
+  parsePrimary() {
+    const token = this.consume();
+    if (token === void 0) {
+      throw new ComputedFormulaParseError("Unexpected end of expression");
+    }
+    switch (token.kind) {
+      case "string":
+      case "number":
+      case "boolean":
+        return { kind: "literal", value: token.value };
+      case "null":
+        return { kind: "literal", value: null };
+      case "identifier":
+        return this.parseIdentifier(token.value);
+      case "punctuation":
+        if (token.value === "(") {
+          const expression = this.parseExpression();
+          this.expectPunctuation(")");
+          return expression;
+        }
+        break;
+      case "operator":
+        if (token.value === "-") {
+          const next = this.consume();
+          if (next?.kind === "number") {
+            return { kind: "literal", value: -next.value };
+          }
+        }
+        break;
+    }
+    throw new ComputedFormulaParseError(
+      `Expected literal, path, call, or parenthesized expression at position ${token.position}`
+    );
+  }
+  parseIdentifier(identifier) {
+    if (this.matchPunctuation("(")) {
+      const args = [];
+      if (!this.matchPunctuation(")")) {
+        do {
+          args.push(this.parseExpression());
+        } while (this.matchPunctuation(","));
+        this.expectPunctuation(")");
+      }
+      return { kind: "call", functionName: identifier.toLowerCase(), args };
+    }
+    const parts = [identifier];
+    while (this.matchPunctuation(".")) {
+      const next = this.consume();
+      if (next?.kind !== "identifier") {
+        const position = next?.position ?? this.previousPosition();
+        throw new ComputedFormulaParseError(
+          `Expected attribute name after path separator at position ${position}`
+        );
+      }
+      parts.push(next.value);
+    }
+    return { kind: "path", parts };
+  }
+  expectPunctuation(value) {
+    if (!this.matchPunctuation(value)) {
+      const token = this.peek();
+      const position = token?.position ?? this.previousPosition();
+      throw new ComputedFormulaParseError(`Expected "${value}" at position ${position}`);
+    }
+  }
+  matchPunctuation(value) {
+    const token = this.peek();
+    if (token?.kind === "punctuation" && token.value === value) {
+      this.consume();
+      return true;
+    }
+    return false;
+  }
+  peek() {
+    return this.tokens[this.position];
+  }
+  consume() {
+    const token = this.tokens[this.position];
+    this.position += 1;
+    return token;
+  }
+  previousPosition() {
+    const previous = this.tokens[this.position - 1];
+    return previous?.position ?? 0;
+  }
+};
+function describeToken(token) {
+  switch (token.kind) {
+    case "identifier":
+    case "number":
+    case "string":
+    case "boolean":
+    case "operator":
+    case "punctuation":
+      return `"${String(token.value)}"`;
+    case "null":
+      return '"null"';
+    default: {
+      const exhaustive = token;
+      return exhaustive;
+    }
+  }
+}
+function getOperatorPrecedence(operator) {
+  switch (operator) {
+    case "*":
+    case "/":
+      return 3;
+    case "+":
+    case "-":
+      return 2;
+    case ">":
+    case "<":
+    case ">=":
+    case "<=":
+    case "==":
+    case "!=":
+      return 1;
+    default: {
+      const exhaustive = operator;
+      return exhaustive;
+    }
+  }
+}
+
+// src/computed/compiler.ts
+var ComputedFormulaCompileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ComputedFormulaCompileError";
+  }
+};
+function compileComputedFormula(input) {
+  const ast = parseCompileFormula(input.expression);
+  const inferred = inferNode(ast, input.schema);
+  const inferredReturnType = valueTypeToReturnType(inferred.valueType);
+  if (inferredReturnType !== input.returnType) {
+    throw new ComputedFormulaCompileError(
+      `Computed formula "${input.attributeName}" returns "${inferredReturnType}", expected "${input.returnType}"`
+    );
+  }
+  if (isSelectLikeReturnType(input.returnType) && inferred.optionsSource === void 0) {
+    throw new ComputedFormulaCompileError(
+      `Computed formula "${input.attributeName}" returns "${input.returnType}" without optionsSource`
+    );
+  }
+  const optionsDependencies = inferred.optionsSource === void 0 ? [] : [{ kind: "options", source: inferred.optionsSource }];
+  const dependencies = uniqueDependencies([...inferred.dependencies, ...optionsDependencies]);
+  return {
+    kind: "formula",
+    attributeName: input.attributeName,
+    expression: input.expression,
+    returnType: input.returnType,
+    valueType: inferred.valueType,
+    dependencies,
+    ...inferred.optionsSource ? { optionsSource: inferred.optionsSource } : {},
+    ...inferred.targetAttributeType ? { targetAttributeType: inferred.targetAttributeType } : {},
+    dependenciesHash: createDependenciesHash({
+      expression: input.expression,
+      returnType: input.returnType,
+      dependencies
+    })
+  };
+}
+function assertAcyclicComputedDependencies(nodes) {
+  const graph = new Map(nodes.map((node) => [node.attributeName, node]));
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (attributeName, activePath) => {
+    const cycleStart = activePath.indexOf(attributeName);
+    if (cycleStart !== -1) {
+      const cycle = [...activePath.slice(cycleStart), attributeName];
+      throw new ComputedFormulaCompileError(`Computed field cycle detected: ${cycle.join(" -> ")}`);
+    }
+    if (visited.has(attributeName)) {
+      return;
+    }
+    const node = graph.get(attributeName);
+    if (node === void 0) {
+      return;
+    }
+    const nextPath = [...activePath, attributeName];
+    for (const dependency of node.dependencies) {
+      if (dependency.kind === "computed") {
+        visit(dependency.attributeName, nextPath);
+      }
+    }
+    visited.add(attributeName);
+  };
+  for (const node of nodes) {
+    visit(node.attributeName, []);
+  }
+}
+function parseCompileFormula(expression) {
+  try {
+    return parseComputedFormula(expression);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new ComputedFormulaCompileError(error.message);
+    }
+    throw error;
+  }
+}
+function inferNode(node, schema) {
+  switch (node.kind) {
+    case "literal":
+      return {
+        valueType: literalToValueType(node.value),
+        dependencies: [],
+        ...typeof node.value === "string" ? { literalString: node.value } : {}
+      };
+    case "path":
+      return inferPath(node.parts, schema);
+    case "call":
+      return inferCall(node.functionName, node.args, schema);
+    case "binary":
+      return inferBinary(
+        node.operator,
+        inferNode(node.left, schema),
+        inferNode(node.right, schema)
+      );
+    default: {
+      const exhaustive = node;
+      return exhaustive;
+    }
+  }
+}
+function literalToValueType(value) {
+  switch (typeof value) {
+    case "string":
+      return { kind: "scalar", type: "text" };
+    case "number":
+      return { kind: "scalar", type: "number" };
+    case "boolean":
+      return { kind: "scalar", type: "boolean" };
+    case "object":
+      return { kind: "scalar", type: "text" };
+    default: {
+      const exhaustive = value;
+      return exhaustive;
+    }
+  }
+}
+function inferPath(parts, schema) {
+  if (parts.length === 1) {
+    const attributeName = parts[0];
+    const attribute = findAttribute(schema, attributeName);
+    if (attribute === void 0) {
+      throw new ComputedFormulaCompileError(
+        `Unknown attribute "${attributeName}" on object "${schema.objectName}"`
+      );
+    }
+    if (attribute.type === "relation") {
+      return {
+        valueType: relationToValueType(),
+        dependencies: [
+          {
+            kind: "relation",
+            relationName: attribute.name,
+            cardinality: relationCardinality(attribute)
+          }
+        ],
+        targetAttributeType: attribute.type
+      };
+    }
+    return {
+      valueType: attributeToValueType(attribute),
+      dependencies: [localDependencyFor(attribute)],
+      optionsSource: optionsSourceForAttribute(schema.objectName, attribute),
+      targetAttributeType: attribute.type
+    };
+  }
+  if (parts.length === 2) {
+    const [relationName, targetAttributeName] = parts;
+    const relation2 = findAttribute(schema, relationName);
+    if (relation2 === void 0) {
+      throw new ComputedFormulaCompileError(
+        `Unknown attribute "${relationName}" on object "${schema.objectName}"`
+      );
+    }
+    if (relation2.type !== "relation") {
+      throw new ComputedFormulaCompileError(
+        `Attribute "${relationName}" on object "${schema.objectName}" is not a relation`
+      );
+    }
+    const targetObjectName = getRelationTargetObjectName(relation2);
+    if (targetObjectName === void 0) {
+      throw new ComputedFormulaCompileError(
+        `Relation "${relationName}" on object "${schema.objectName}" is missing targetObjectName`
+      );
+    }
+    const targetObject = schema.relatedObjects?.[targetObjectName];
+    if (targetObject === void 0) {
+      throw new ComputedFormulaCompileError(`Unknown related object "${targetObjectName}"`);
+    }
+    const targetAttribute = findAttribute(targetObject, targetAttributeName);
+    if (targetAttribute === void 0) {
+      throw new ComputedFormulaCompileError(
+        `Unknown attribute "${targetAttributeName}" on object "${targetObject.objectName}"`
+      );
+    }
+    const targetValueType = attributeToValueType(targetAttribute);
+    return {
+      valueType: relation2.cardinality === "many" ? asCollectionValueType(targetValueType) : targetValueType,
+      dependencies: [
+        {
+          kind: "relation",
+          relationName,
+          targetAttributeName,
+          cardinality: relationCardinality(relation2)
+        }
+      ],
+      optionsSource: optionsSourceForAttribute(targetObject.objectName, targetAttribute),
+      targetAttributeType: targetAttribute.type
+    };
+  }
+  throw new ComputedFormulaCompileError("Computed paths support at most one relation hop");
+}
+function findAttribute(object2, attributeName) {
+  return object2.attributes.find((attribute) => attribute.name === attributeName);
+}
+function getRelationTargetObjectName(attribute) {
+  if (attribute.targetObjectName !== void 0) {
+    return attribute.targetObjectName;
+  }
+  if (attribute.targets?.length === 1) {
+    const [target] = attribute.targets;
+    return target?.object === "*" ? void 0 : target?.object;
+  }
+  return void 0;
+}
+function relationCardinality(attribute) {
+  return attribute.cardinality ?? "one";
+}
+function localDependencyFor(attribute) {
+  if (attribute.type === "formula" || attribute.type === "rollup") {
+    return { kind: "computed", attributeName: attribute.name };
+  }
+  return { kind: "local", attributeName: attribute.name };
+}
+function attributeToValueType(attribute) {
+  if (attribute.type === "formula" || attribute.type === "rollup") {
+    if (attribute.returnType === void 0) {
+      throw new ComputedFormulaCompileError(
+        `Computed attribute "${attribute.name}" is missing returnType`
+      );
+    }
+    return returnTypeToValueType(attribute.returnType);
+  }
+  switch (attribute.type) {
+    case "number":
+    case "currency":
+      return { kind: "scalar", type: "number" };
+    case "checkbox":
+      return { kind: "scalar", type: "boolean" };
+    case "date":
+      return { kind: "scalar", type: "date" };
+    case "select":
+    case "status":
+      return { kind: "scalar", type: "select" };
+    case "multiselect":
+      return { kind: "collection", itemType: "select" };
+    case "text":
+    case "richtext":
+    case "phone":
+    case "file":
+    case "user":
+    case "location":
+    case "relation":
+    case "document":
+      return { kind: "scalar", type: "text" };
+    default: {
+      const exhaustive = attribute.type;
+      return exhaustive;
+    }
+  }
+}
+function relationToValueType() {
+  return { kind: "collection", itemType: "text" };
+}
+function returnTypeToValueType(returnType) {
+  if (returnType === "multiselect") {
+    return { kind: "collection", itemType: "select" };
+  }
+  return { kind: "scalar", type: returnType };
+}
+function asCollectionValueType(valueType) {
+  if (valueType.kind === "collection") {
+    return valueType;
+  }
+  return { kind: "collection", itemType: valueType.type };
+}
+function optionsSourceForAttribute(objectName, attribute) {
+  if (attribute.type === "formula" || attribute.type === "rollup") {
+    if (!isSelectLikeReturnType(attribute.returnType)) {
+      return void 0;
+    }
+    return attribute.optionsSource;
+  }
+  if (attribute.type !== "select" && attribute.type !== "status" && attribute.type !== "multiselect") {
+    return void 0;
+  }
+  return attribute.optionsSource ?? {
+    objectName,
+    attributeName: attribute.name,
+    ...attribute.id ? { attributeId: attribute.id } : {}
+  };
+}
+function inferCall(functionName, args, schema) {
+  if (!isComputedFunctionName(functionName)) {
+    throw new ComputedFormulaCompileError(`Unknown computed function "${functionName}"`);
+  }
+  const signature = COMPUTED_FUNCTIONS[functionName];
+  if (args.length < signature.minArgs || signature.maxArgs !== void 0 && args.length > signature.maxArgs) {
+    const expected = signature.maxArgs === void 0 || signature.maxArgs === signature.minArgs ? String(signature.minArgs) : `${signature.minArgs}-${signature.maxArgs}`;
+    throw new ComputedFormulaCompileError(
+      `Function "${functionName}" expects ${expected} arguments, received ${args.length}`
+    );
+  }
+  const inferredArgs = args.map((arg) => inferNode(arg, schema));
+  return inferFunctionReturn(functionName, inferredArgs);
+}
+function inferFunctionReturn(functionName, args) {
+  const dependencies = uniqueDependencies(args.flatMap((arg) => arg.dependencies));
+  switch (functionName) {
+    case "if":
+      return inferIfFunction(args, dependencies);
+    case "concat":
+      ensureNoCollections(args, `Function "${functionName}" does not accept collection values`);
+      return { valueType: { kind: "scalar", type: "text" }, dependencies };
+    case "sum":
+    case "avg":
+      ensureNumericCollectionOrScalar(functionName, args[0]);
+      return { valueType: { kind: "scalar", type: "number" }, dependencies };
+    case "count":
+    case "count_empty":
+    case "count_not_empty":
+    case "count_unique":
+    case "percent_empty":
+    case "percent_not_empty":
+      if (functionName === "count_unique") {
+        ensureUniqueCountSource(args[0]);
+      } else {
+        ensureCollectionSource(functionName, args[0]);
+      }
+      return { valueType: { kind: "scalar", type: "number" }, dependencies };
+    case "min":
+    case "max":
+      ensureMinMaxSource(functionName, args[0]);
+      return {
+        valueType: sourceItemValueType(args[0]),
+        dependencies,
+        optionsSource: args[0].optionsSource,
+        targetAttributeType: args[0].targetAttributeType
+      };
+    case "earliest":
+    case "latest":
+      ensureDateCollectionOrScalar(functionName, args[0]);
+      return {
+        valueType: { kind: "scalar", type: "date" },
+        dependencies,
+        targetAttributeType: args[0].targetAttributeType
+      };
+    case "unique":
+      return inferUniqueFunction(args[0], dependencies);
+    case "first":
+      return inferFirstFunction(args[0], dependencies);
+    default: {
+      const exhaustive = functionName;
+      return exhaustive;
+    }
+  }
+}
+function inferIfFunction(args, dependencies) {
+  ensureScalarType(args[0].valueType, "boolean", 'Function "if" condition must be boolean');
+  const thenValue = args[1];
+  const elseValue = args[2];
+  const valueType = resolveIfBranchValueType(thenValue, elseValue);
+  const optionsSource = resolveIfOptionsSource(thenValue, elseValue);
+  if (valueType === void 0) {
+    throw new ComputedFormulaCompileError('Function "if" branches must return the same type');
+  }
+  return {
+    valueType,
+    dependencies,
+    ...optionsSource ? { optionsSource } : {},
+    targetAttributeType: thenValue.targetAttributeType ?? elseValue.targetAttributeType
+  };
+}
+function inferUniqueFunction(source, dependencies) {
+  if (source.valueType.kind !== "collection" || source.valueType.itemType !== "select") {
+    throw new ComputedFormulaCompileError('Function "unique" expects a select collection');
+  }
+  return {
+    valueType: { kind: "collection", itemType: "select" },
+    dependencies,
+    optionsSource: source.optionsSource,
+    targetAttributeType: source.targetAttributeType
+  };
+}
+function inferFirstFunction(source, dependencies) {
+  if (source.valueType.kind !== "collection") {
+    throw new ComputedFormulaCompileError('Function "first" expects a collection');
+  }
+  return {
+    valueType: { kind: "scalar", type: source.valueType.itemType },
+    dependencies,
+    optionsSource: source.optionsSource,
+    targetAttributeType: source.targetAttributeType
+  };
+}
+function inferBinary(operator, left, right) {
+  const dependencies = uniqueDependencies([...left.dependencies, ...right.dependencies]);
+  if (operator === "+" || operator === "-" || operator === "*" || operator === "/") {
+    if (left.valueType.kind === "collection" || right.valueType.kind === "collection") {
+      throw new ComputedFormulaCompileError(
+        `Cannot use collection values with arithmetic operator "${operator}"`
+      );
+    }
+    if (operator === "+" && (left.valueType.type === "text" || right.valueType.type === "text")) {
+      return { valueType: { kind: "scalar", type: "text" }, dependencies };
+    }
+    ensureScalarType(left.valueType, "number", `Operator "${operator}" expects number operands`);
+    ensureScalarType(right.valueType, "number", `Operator "${operator}" expects number operands`);
+    return { valueType: { kind: "scalar", type: "number" }, dependencies };
+  }
+  if (left.valueType.kind === "collection" || right.valueType.kind === "collection") {
+    throw new ComputedFormulaCompileError(
+      `Cannot use collection values with comparison operator "${operator}"`
+    );
+  }
+  if (operator === "==" || operator === "!=") {
+    if (left.valueType.type !== right.valueType.type) {
+      throw new ComputedFormulaCompileError(
+        `Operator "${operator}" expects operands with the same scalar type`
+      );
+    }
+    return { valueType: { kind: "scalar", type: "boolean" }, dependencies };
+  }
+  if ((left.valueType.type !== "number" || right.valueType.type !== "number") && (left.valueType.type !== "date" || right.valueType.type !== "date")) {
+    throw new ComputedFormulaCompileError(
+      `Operator "${operator}" expects number or date operands of the same type`
+    );
+  }
+  return { valueType: { kind: "scalar", type: "boolean" }, dependencies };
+}
+function ensureNoCollections(args, message) {
+  for (const arg of args) {
+    if (arg.valueType.kind === "collection") {
+      throw new ComputedFormulaCompileError(message);
+    }
+  }
+}
+function ensureNumericCollectionOrScalar(functionName, expression) {
+  const type = expression.valueType.kind === "collection" ? expression.valueType.itemType : expression.valueType.type;
+  if (type !== "number") {
+    throw new ComputedFormulaCompileError(`Function "${functionName}" expects number values`);
+  }
+}
+function ensureDateCollectionOrScalar(functionName, expression) {
+  const type = expression.valueType.kind === "collection" ? expression.valueType.itemType : expression.valueType.type;
+  if (type !== "date") {
+    throw new ComputedFormulaCompileError(`Function "${functionName}" expects date values`);
+  }
+}
+function ensureMinMaxSource(functionName, expression) {
+  if (expression.valueType.kind !== "collection") {
+    throw new ComputedFormulaCompileError(`Function "${functionName}" expects a collection`);
+  }
+  const type = expression.valueType.itemType;
+  if (type !== "number" && type !== "date") {
+    throw new ComputedFormulaCompileError(
+      `Function "${functionName}" expects number or date values`
+    );
+  }
+}
+function ensureCollectionSource(functionName, expression) {
+  if (expression.valueType.kind !== "collection") {
+    throw new ComputedFormulaCompileError(`Function "${functionName}" expects a collection`);
+  }
+}
+function ensureUniqueCountSource(expression) {
+  if (expression.valueType.kind !== "collection") {
+    throw new ComputedFormulaCompileError('Function "count_unique" expects a collection');
+  }
+}
+function ensureScalarType(valueType, expectedType, message) {
+  if (valueType.kind !== "scalar" || valueType.type !== expectedType) {
+    throw new ComputedFormulaCompileError(message);
+  }
+}
+function sourceItemValueType(source) {
+  if (source.valueType.kind === "scalar") {
+    return source.valueType;
+  }
+  return { kind: "scalar", type: source.valueType.itemType };
+}
+function sameValueType(left, right) {
+  if (left.kind === "scalar") {
+    return right.kind === "scalar" && left.type === right.type;
+  }
+  return right.kind === "collection" && left.itemType === right.itemType;
+}
+function resolveIfBranchValueType(thenValue, elseValue) {
+  if (sameValueType(thenValue.valueType, elseValue.valueType)) {
+    return thenValue.valueType;
+  }
+  if (isSelectScalarWithStringLiteral(thenValue, elseValue)) {
+    return thenValue.valueType;
+  }
+  if (isSelectScalarWithStringLiteral(elseValue, thenValue)) {
+    return elseValue.valueType;
+  }
+  return void 0;
+}
+function isSelectScalarWithStringLiteral(selectValue, literalValue) {
+  return selectValue.valueType.kind === "scalar" && selectValue.valueType.type === "select" && literalValue.valueType.kind === "scalar" && literalValue.valueType.type === "text" && literalValue.literalString !== void 0;
+}
+function resolveIfOptionsSource(thenValue, elseValue) {
+  const thenSource = thenValue.optionsSource;
+  const elseSource = elseValue.optionsSource;
+  if (thenSource !== void 0 && elseSource !== void 0 && !sameOptionsSource(thenSource, elseSource)) {
+    throw new ComputedFormulaCompileError(
+      'Function "if" branches use incompatible options sources'
+    );
+  }
+  return thenSource ?? elseSource;
+}
+function sameOptionsSource(left, right) {
+  return left.objectName === right.objectName && left.attributeName === right.attributeName && left.attributeId === right.attributeId;
+}
+function isSelectLikeReturnType(returnType) {
+  return returnType === "select" || returnType === "multiselect";
+}
+function valueTypeToReturnType(valueType) {
+  if (valueType.kind === "scalar") {
+    return valueType.type;
+  }
+  if (valueType.itemType === "select") {
+    return "multiselect";
+  }
+  throw new ComputedFormulaCompileError(
+    `Collection item type "${valueType.itemType}" cannot be used as a computed return type`
+  );
+}
+function uniqueDependencies(dependencies) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const dependency of dependencies) {
+    const key = JSON.stringify(stableNormalize(dependency));
+    if (!seen.has(key)) {
+      seen.add(key);
+      unique.push(dependency);
+    }
+  }
+  return unique;
+}
+function createDependenciesHash(input) {
+  const sortedDependencies = input.dependencies.map((dependency) => stableNormalize(dependency)).sort((left, right) => compareStrings(JSON.stringify(left), JSON.stringify(right)));
+  return JSON.stringify(
+    stableNormalize({
+      expression: input.expression,
+      returnType: input.returnType,
+      dependencies: sortedDependencies
+    })
+  );
+}
+function stableNormalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stableNormalize(item));
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => compareStrings(left, right)).map(([key, item]) => [key, stableNormalize(item)])
+    );
+  }
+  return value;
+}
+function compareStrings(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+
+// src/computed/rollup-compiler.ts
+function rollupToFormulaExpression(attr) {
+  if (attr.function === "count") {
+    return `count(${attr.relationAttribute})`;
+  }
+  return `${rollupFunctionToFormulaFunction(attr.function)}(${attr.relationAttribute}.${attr.targetAttribute})`;
+}
+function inferRollupReturnType(attr, schema) {
+  if (attr.function === "count") {
+    return "number";
+  }
+  const targetAttribute = findRollupTargetAttribute(attr, schema);
+  switch (attr.function) {
+    case "countValues":
+    case "countEmpty":
+    case "percentEmpty":
+    case "percentNotEmpty":
+    case "countUniqueValues":
+      return "number";
+    case "sum":
+    case "avg":
+      return "number";
+    case "earliest":
+    case "latest":
+      return "date";
+    case "original":
+      if (!isSelectLikeAttributeType(targetAttribute.type)) {
+        throw new ComputedFormulaCompileError(
+          `Rollup "original" requires a select, status, or multiselect target`
+        );
+      }
+      return "multiselect";
+    default: {
+      const exhaustive = attr.function;
+      return exhaustive;
+    }
+  }
+}
+function compileRollupAttribute(attr, schema) {
+  const expression = rollupToFormulaExpression(attr);
+  const returnType = inferRollupReturnType(attr, schema);
+  const plan = compileComputedFormula({
+    attributeName: attr.name,
+    expression,
+    returnType,
+    schema: schemaWithRollupRelationAsMany(attr, schema)
+  });
+  return {
+    ...plan,
+    kind: "rollup"
+  };
+}
+function schemaWithRollupRelationAsMany(attr, schema) {
+  return {
+    ...schema,
+    attributes: schema.attributes.map(
+      (attribute) => attribute.name === attr.relationAttribute && attribute.type === "relation" ? { ...attribute, cardinality: "many" } : attribute
+    )
+  };
+}
+function rollupFunctionToFormulaFunction(functionName) {
+  switch (functionName) {
+    case "sum":
+    case "avg":
+    case "earliest":
+    case "latest":
+      return functionName;
+    case "original":
+      return "unique";
+    case "countValues":
+      return "count_not_empty";
+    case "countEmpty":
+      return "count_empty";
+    case "percentEmpty":
+      return "percent_empty";
+    case "percentNotEmpty":
+      return "percent_not_empty";
+    case "countUniqueValues":
+      return "count_unique";
+    default: {
+      const exhaustive = functionName;
+      return exhaustive;
+    }
+  }
+}
+function findRollupTargetAttribute(attr, schema) {
+  const relation2 = findAttribute2(schema, attr.relationAttribute);
+  if (relation2 === void 0) {
+    throw new ComputedFormulaCompileError(
+      `Unknown relation attribute "${attr.relationAttribute}" on object "${schema.objectName}"`
+    );
+  }
+  if (relation2.type !== "relation") {
+    throw new ComputedFormulaCompileError(
+      `Attribute "${attr.relationAttribute}" on object "${schema.objectName}" is not a relation`
+    );
+  }
+  const targetObjectName = getRelationTargetObjectName2(relation2);
+  if (targetObjectName === void 0) {
+    throw new ComputedFormulaCompileError(
+      `Relation "${attr.relationAttribute}" on object "${schema.objectName}" is missing targetObjectName`
+    );
+  }
+  const targetObject = schema.relatedObjects?.[targetObjectName];
+  if (targetObject === void 0) {
+    throw new ComputedFormulaCompileError(`Unknown related object "${targetObjectName}"`);
+  }
+  const targetAttribute = findAttribute2(targetObject, attr.targetAttribute);
+  if (targetAttribute === void 0) {
+    throw new ComputedFormulaCompileError(
+      `Unknown attribute "${attr.targetAttribute}" on object "${targetObject.objectName}"`
+    );
+  }
+  return targetAttribute;
+}
+function findAttribute2(object2, attributeName) {
+  return object2.attributes.find((attribute) => attribute.name === attributeName);
+}
+function getRelationTargetObjectName2(attribute) {
+  if (attribute.targetObjectName !== void 0) {
+    return attribute.targetObjectName;
+  }
+  if (attribute.targets?.length === 1) {
+    const [target] = attribute.targets;
+    return target?.object === "*" ? void 0 : target?.object;
+  }
+  return void 0;
+}
+function isSelectLikeAttributeType(type) {
+  return type === "select" || type === "status" || type === "multiselect";
+}
+
+// src/computed/evaluator.ts
+function evaluateAst(node, input) {
+  switch (node.kind) {
+    case "literal":
+      return node.value;
+    case "path":
+      return resolvePath(input, node.parts);
+    case "binary":
+      return evaluateBinary(
+        node.operator,
+        evaluateAst(node.left, input),
+        evaluateAst(node.right, input)
+      );
+    case "call":
+      return evaluateCallNode(node.functionName, node.args, input);
+    default:
+      return unreachable(node);
+  }
+}
+function evaluateCallNode(functionName, args, input) {
+  assertComputedFunctionName(functionName);
+  validateArity(functionName, args.length);
+  if (functionName === "if") {
+    return evaluateAst(args[0], input) ? evaluateAst(args[1], input) : evaluateAst(args[2], input);
+  }
+  return evaluateCall(
+    functionName,
+    args.map((arg) => evaluateAst(arg, input))
+  );
+}
+function resolvePath(input, parts) {
+  return parts.reduce((value, part) => resolvePathPart(value, part), input);
+}
+function resolvePathPart(value, part) {
+  if (Array.isArray(value)) {
+    return value.map((item) => resolvePathPart(item, part));
+  }
+  if (!isPlainRecord(value)) {
+    return null;
+  }
+  if (Object.hasOwn(value, part)) {
+    return value[part] ?? null;
   }
-  let order = 1;
-  for (const tab of preservedTabs) {
-    result.push({ ...tab, order: order++ });
+  const nestedValues = value.values;
+  if (isPlainRecord(nestedValues) && Object.hasOwn(nestedValues, part)) {
+    return nestedValues[part] ?? null;
   }
-  for (const tab of otherTabs) {
-    result.push({ ...tab, order: order++ });
+  return null;
+}
+function evaluateBinary(operator, left, right) {
+  switch (operator) {
+    case "+":
+      return add(left, right);
+    case "-":
+      return numericBinary(left, right, (leftNumber, rightNumber) => leftNumber - rightNumber);
+    case "*":
+      return numericBinary(left, right, (leftNumber, rightNumber) => leftNumber * rightNumber);
+    case "/":
+      return numericBinary(left, right, (leftNumber, rightNumber) => leftNumber / rightNumber);
+    case ">":
+      return compareWith(left, right, (result) => result > 0);
+    case "<":
+      return compareWith(left, right, (result) => result < 0);
+    case ">=":
+      return compareWith(left, right, (result) => result >= 0);
+    case "<=":
+      return compareWith(left, right, (result) => result <= 0);
+    case "==":
+      return equalScalar(left, right);
+    case "!=":
+      return !equalScalar(left, right);
+    default:
+      return unreachable(operator);
   }
-  return result;
 }
-function resetDetailViewToDefault(view, object2, options) {
-  const { preserveMetadata = true, ...generateOptions } = options;
-  const defaultView = generateDefaultDetailView(object2, generateOptions);
-  const preservedTabs = getPreservedDetailTabs(view, options);
-  const mergedTabs = mergeDetailTabs(defaultView.config.tabs, preservedTabs);
-  const config = {
-    ...defaultView.config,
-    tabs: mergedTabs
-  };
-  const resetView = {
-    ...defaultView,
-    config
-  };
-  if (preserveMetadata) {
-    resetView.id = view.id;
-    resetView.name = view.name;
-    resetView.label = view.label;
-    resetView.description = view.description;
-    resetView.icon = view.icon;
+function add(left, right) {
+  if (typeof left === "string" || typeof right === "string") {
+    return `${left ?? ""}${right ?? ""}`;
   }
-  return resetView;
+  return numericBinary(left, right, (leftNumber, rightNumber) => leftNumber + rightNumber);
 }
-function resetListViewToDefault(view, object2, options) {
-  const { preserveMetadata = true, ...generateOptions } = options;
-  const defaultView = generateDefaultListView(object2, generateOptions);
-  const resetView = {
-    ...defaultView
-  };
-  if (preserveMetadata) {
-    resetView.id = view.id;
-    resetView.name = view.name;
-    resetView.label = view.label;
-    resetView.description = view.description;
-    resetView.icon = view.icon;
+function compareWith(left, right, predicate) {
+  const result = compare(left, right);
+  return result === null ? null : predicate(result);
+}
+function compare(left, right) {
+  const leftNumber = toFiniteNumber(left);
+  const rightNumber = toFiniteNumber(right);
+  if (leftNumber !== null && rightNumber !== null) {
+    return leftNumber - rightNumber;
   }
-  return resetView;
+  const leftDate = toDate(left);
+  const rightDate = toDate(right);
+  return leftDate && rightDate ? leftDate.getTime() - rightDate.getTime() : null;
 }
-function resetViewToDefault(currentView, object2, options = {}) {
-  if (isDetailView(currentView)) {
-    return resetDetailViewToDefault(currentView, object2, options);
+function equalScalar(left, right) {
+  if (left === right) {
+    return true;
   }
-  if (isListView(currentView)) {
-    return resetListViewToDefault(currentView, object2, options);
+  if (left === null || left === void 0 || right === null || right === void 0) {
+    return false;
   }
-  throw new Error(`Reset not supported for view type: ${currentView.type}`);
+  return compare(left, right) === 0;
 }
-
-// src/views/index.ts
-function getActiveTab(config, tabId) {
-  if (tabId) {
-    const tab = config.tabs.find((t) => t.id === tabId);
-    if (tab) return tab;
+function assertComputedFunctionName(name) {
+  if (!isComputedFunctionName(name)) {
+    throw new Error(`Unknown computed function "${name}"`);
   }
-  return config.tabs.find((t) => t.default) ?? config.tabs[0];
 }
-
-// src/forms/registry.ts
-var FormRegistry = class {
-  constructor() {
-    this.forms = /* @__PURE__ */ new Map();
-  }
-  /**
-   * Register a form definition (or array of definitions).
-   * @throws Error if a form with the same name is already registered.
-   */
-  register(formOrForms) {
-    const forms = Array.isArray(formOrForms) ? formOrForms : [formOrForms];
-    for (const f of forms) {
-      if (this.forms.has(f.name)) {
-        throw new Error(`[FormRegistry] Duplicate form: "${f.name}"`);
-      }
-      this.forms.set(f.name, f);
-    }
-    return this;
-  }
-  /**
-   * Get a form definition by name.
-   */
-  get(name) {
-    return this.forms.get(name);
+function validateArity(functionName, actual) {
+  const { minArgs, maxArgs } = COMPUTED_FUNCTIONS[functionName];
+  if (actual >= minArgs && actual <= (maxArgs ?? Number.POSITIVE_INFINITY)) {
+    return;
   }
-  /**
-   * Get all registered form definitions.
-   */
-  getAll() {
-    return Array.from(this.forms.values());
+  const range = maxArgs === void 0 ? `at least ${minArgs}` : `between ${minArgs} and ${maxArgs}`;
+  throw new Error(`Function "${functionName}" expects ${range} arguments, received ${actual}`);
+}
+function evaluateCall(functionName, args) {
+  switch (functionName) {
+    case "concat":
+      return args.filter((arg) => arg !== null && arg !== void 0).map(String).join("");
+    case "sum":
+      return numericValues(args).reduce((total, value) => total + value, 0);
+    case "avg": {
+      const values = numericValues(args);
+      return values.length > 0 ? values.reduce((total, value) => total + value, 0) / values.length : null;
+    }
+    case "count":
+      return collectionItems(args[0]).length;
+    case "min":
+      return minMax(args, "min");
+    case "max":
+      return minMax(args, "max");
+    case "earliest":
+      return dateMinMax(args, "min");
+    case "latest":
+      return dateMinMax(args, "max");
+    case "unique":
+      return uniqueNonEmpty(collectionItems(args[0]));
+    case "first":
+      return collectionItems(args[0]).find((item) => item !== null && item !== void 0) ?? null;
+    case "percent_empty":
+      return percentByEmptyState(args[0], true);
+    case "percent_not_empty":
+      return percentByEmptyState(args[0], false);
+    case "count_empty":
+      return collectionItems(args[0]).filter(isEmptyValue).length;
+    case "count_not_empty":
+      return collectionItems(args[0]).filter((item) => !isEmptyValue(item)).length;
+    case "count_unique":
+      return uniqueNonEmpty(collectionItems(args[0])).length;
+    default:
+      return unreachable(functionName);
   }
-  /**
-   * List all registered form names.
-   */
-  listNames() {
-    return Array.from(this.forms.keys());
+}
+function unreachable(value) {
+  return value;
+}
+function numericValues(values) {
+  return flatten(values).map(toFiniteNumber).filter((value) => value !== null);
+}
+function numericBinary(left, right, operation) {
+  const leftNumber = toFiniteNumber(left);
+  const rightNumber = toFiniteNumber(right);
+  if (leftNumber === null || rightNumber === null) {
+    return null;
   }
-};
-var formRegistry = new FormRegistry();
-var DOS_PROTECTION_LIMITS = {
-  MAX_EXPRESSION_LENGTH: 1e4,
-  MAX_TOKEN_COUNT: 1e3,
-  MAX_NESTING_DEPTH: 50
-};
-function createFormulaParser() {
-  const parser = new exprEval.Parser();
-  parser.functions.IF = (condition, thenValue, elseValue) => condition ? thenValue : elseValue;
-  parser.functions.AND = (...args) => args.every(Boolean);
-  parser.functions.OR = (...args) => args.some(Boolean);
-  parser.functions.NOT = (value) => !value;
-  parser.functions.EMPTY = (value) => value === null || value === void 0 || value === "";
-  parser.functions.COALESCE = (...args) => args.find((a) => a != null) ?? null;
-  parser.functions.DEFAULT = (value, defaultValue) => value == null || value === "" ? defaultValue : value;
-  parser.functions.CONCAT = (...args) => args.filter((a) => a != null).map(String).join("");
-  parser.functions.UPPER = (value) => String(value ?? "").toUpperCase();
-  parser.functions.LOWER = (value) => String(value ?? "").toLowerCase();
-  parser.functions.TRIM = (value) => String(value ?? "").trim();
-  parser.functions.LENGTH = (value) => String(value ?? "").length;
-  parser.functions.LEFT = (value, count) => String(value ?? "").slice(0, count);
-  parser.functions.RIGHT = (value, count) => String(value ?? "").slice(-count);
-  parser.functions.REPLACE = (value, search, replacement) => String(value ?? "").split(String(search)).join(replacement);
-  parser.functions.CONTAINS = (value, search) => String(value ?? "").toLowerCase().includes(String(search).toLowerCase());
-  parser.functions.ROUND = (value, decimals = 0) => {
-    if (typeof value !== "number" || Number.isNaN(value)) return null;
-    const factor = 10 ** decimals;
-    return Math.round(value * factor) / factor;
-  };
-  parser.functions.FLOOR = (value) => {
-    if (typeof value !== "number" || Number.isNaN(value)) return null;
-    return Math.floor(value);
-  };
-  parser.functions.CEIL = (value) => {
-    if (typeof value !== "number" || Number.isNaN(value)) return null;
-    return Math.ceil(value);
-  };
-  parser.functions.ABS = (value) => {
-    if (typeof value !== "number" || Number.isNaN(value)) return null;
-    return Math.abs(value);
-  };
-  parser.functions.MIN = (...args) => {
-    const nums = args.filter((n) => typeof n === "number" && !Number.isNaN(n));
-    return nums.length > 0 ? Math.min(...nums) : null;
-  };
-  parser.functions.MAX = (...args) => {
-    const nums = args.filter((n) => typeof n === "number" && !Number.isNaN(n));
-    return nums.length > 0 ? Math.max(...nums) : null;
-  };
-  parser.functions.POW = (base, exponent) => {
-    if (typeof base !== "number" || typeof exponent !== "number") return null;
-    if (exponent > 1e3 || exponent < -1e3) return null;
-    return base ** exponent;
-  };
-  parser.functions.MOD = (a, b) => {
-    if (typeof a !== "number" || typeof b !== "number" || b === 0) return null;
-    return a % b;
-  };
-  parser.functions.NOW = () => (/* @__PURE__ */ new Date()).toISOString();
-  parser.functions.TODAY = () => (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  parser.functions.YEAR = (value) => {
-    const date2 = parseDate(value);
-    return date2 ? date2.getFullYear() : null;
-  };
-  parser.functions.MONTH = (value) => {
-    const date2 = parseDate(value);
-    return date2 ? date2.getMonth() + 1 : null;
-  };
-  parser.functions.DAY = (value) => {
-    const date2 = parseDate(value);
-    return date2 ? date2.getDate() : null;
-  };
-  parser.functions.DATE_DIFF = (date1, date2, unit = "days") => {
-    const d1 = parseDate(date1);
-    const d2 = parseDate(date2);
-    if (d1 === null || d2 === null) return null;
-    const diffMs = d1.getTime() - d2.getTime();
-    const MS_PER_DAY = 1e3 * 60 * 60 * 24;
-    const conversions = {
-      years: MS_PER_DAY * 365,
-      months: MS_PER_DAY * 30,
-      weeks: MS_PER_DAY * 7,
-      days: MS_PER_DAY,
-      hours: 1e3 * 60 * 60,
-      minutes: 1e3 * 60
-    };
-    const divisor = conversions[unit] ?? MS_PER_DAY;
-    return diffMs / divisor;
-  };
-  return parser;
+  const result = operation(leftNumber, rightNumber);
+  return Number.isFinite(result) ? result : null;
 }
-function parseDate(value) {
-  if (!value) return null;
-  if (value instanceof Date) return value;
-  if (typeof value === "string" || typeof value === "number") {
-    const date2 = new Date(value);
-    return Number.isNaN(date2.getTime()) ? null : date2;
+function minMax(values, mode) {
+  const numbers = numericValues(values);
+  if (numbers.length > 0) {
+    return mode === "min" ? Math.min(...numbers) : Math.max(...numbers);
   }
-  return null;
+  return dateMinMax(values, mode);
 }
-var formulaParser = createFormulaParser();
-function validateFormulaComplexity(expression) {
-  if (expression.length > DOS_PROTECTION_LIMITS.MAX_EXPRESSION_LENGTH) {
-    return {
-      valid: false,
-      error: `Expression too long (${expression.length} chars, max ${DOS_PROTECTION_LIMITS.MAX_EXPRESSION_LENGTH})`
-    };
+function dateMinMax(values, mode) {
+  const dates = flatten(values).map(toDate).filter((date2) => date2 !== null);
+  if (dates.length === 0) {
+    return null;
   }
-  const nestingDepth = calculateNestingDepth(expression);
-  if (nestingDepth > DOS_PROTECTION_LIMITS.MAX_NESTING_DEPTH) {
-    return {
-      valid: false,
-      error: `Expression too deeply nested (${nestingDepth} levels, max ${DOS_PROTECTION_LIMITS.MAX_NESTING_DEPTH})`
-    };
+  const timestamps = dates.map((date2) => date2.getTime());
+  const timestamp = mode === "min" ? Math.min(...timestamps) : Math.max(...timestamps);
+  return new Date(timestamp).toISOString();
+}
+function percentByEmptyState(value, countEmpty) {
+  const items = collectionItems(value);
+  if (items.length === 0) {
+    return 0;
   }
-  try {
-    formulaParser.parse(expression);
-    const tokenCountApprox = estimateTokenCount(expression);
-    if (tokenCountApprox > DOS_PROTECTION_LIMITS.MAX_TOKEN_COUNT) {
-      return {
-        valid: false,
-        error: `Expression too complex (approx ${tokenCountApprox} tokens, max ${DOS_PROTECTION_LIMITS.MAX_TOKEN_COUNT})`
-      };
+  const count = items.filter((item) => isEmptyValue(item) === countEmpty).length;
+  return count / items.length;
+}
+function uniqueNonEmpty(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const value of values) {
+    if (isEmptyValue(value)) {
+      continue;
     }
-    return { valid: true };
-  } catch {
-    return { valid: true };
+    const key = uniqueKey(value);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    result.push(value);
+  }
+  return result;
+}
+function collectionItems(value) {
+  if (value === null || value === void 0) {
+    return [];
   }
+  return Array.isArray(value) ? flatten(value) : [value];
 }
-function estimateTokenCount(expression) {
-  const tokens = expression.match(/-?\d+\.?\d*|[a-zA-Z_][a-zA-Z0-9_]*|[+\-*/(),.><=!&|]+|'(?:[^'\\]|\\.)*'/g) ?? [];
-  return tokens.length;
+function flatten(values) {
+  return values.flat(Number.POSITIVE_INFINITY);
 }
-function calculateNestingDepth(expression) {
-  let maxDepth = 0;
-  let currentDepth = 0;
-  for (const char of expression) {
-    if (char === "(") {
-      currentDepth++;
-      if (currentDepth > maxDepth) maxDepth = currentDepth;
-    } else if (char === ")") {
-      currentDepth--;
-    }
+function isEmptyValue(value) {
+  return value === null || value === void 0 || value === "";
+}
+function toFiniteNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
   }
-  return maxDepth;
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
 }
-function evaluateFormula(expression, values) {
-  try {
-    const complexityCheck = validateFormulaComplexity(expression);
-    if (!complexityCheck.valid) {
-      console.warn(`[formula] Complexity limit violated: ${complexityCheck.error}`);
-      return null;
-    }
-    const parsed = formulaParser.parse(expression);
-    return parsed.evaluate(values);
-  } catch {
+function toDate(value) {
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? null : value;
+  }
+  if (typeof value !== "string") {
     return null;
   }
+  const date2 = new Date(value);
+  return Number.isNaN(date2.getTime()) ? null : date2;
 }
-function evaluateFormulaWithResult(expression, values) {
-  try {
-    const complexityCheck = validateFormulaComplexity(expression);
-    if (!complexityCheck.valid) {
-      return { value: null, error: complexityCheck.error };
-    }
-    const parsed = formulaParser.parse(expression);
-    const value = parsed.evaluate(values);
-    return { value };
-  } catch (error) {
-    return { value: null, error: getErrorMessage(error) };
+function uniqueKey(value) {
+  const numberValue = toFiniteNumber(value);
+  if (numberValue !== null) {
+    return `number:${numberValue}`;
   }
+  if (value instanceof Date) {
+    return `date:${value.toISOString()}`;
+  }
+  return `${typeof value}:${JSON.stringify(value)}`;
 }
-function formatFormulaResult(value, returnType, decimals) {
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatComputedResult(value, returnType, decimals) {
   if (value === null || value === void 0) return null;
+  const stringifyScalar = (input) => {
+    if (typeof input === "string" || typeof input === "number" || typeof input === "boolean" || input instanceof Date) {
+      return String(input);
+    }
+    return null;
+  };
   switch (returnType) {
     case "number": {
       const num = typeof value === "number" ? value : Number(value);
@@ -4949,152 +6439,163 @@ function formatFormulaResult(value, returnType, decimals) {
       return null;
     case "text":
       return String(value);
-  }
-}
-function evaluateFormulaAttribute(attr, values) {
-  const raw = evaluateFormula(attr.expression, values);
-  return formatFormulaResult(raw, attr.returnType, attr.decimals);
-}
-function validateFormulaExpression(expression) {
-  try {
-    const complexityCheck = validateFormulaComplexity(expression);
-    if (!complexityCheck.valid) return complexityCheck;
-    formulaParser.parse(expression);
-    return { valid: true };
-  } catch (error) {
-    return { valid: false, error: getErrorMessage(error) };
-  }
-}
-function extractFormulaVariables(expression) {
-  try {
-    const parsed = formulaParser.parse(expression);
-    return parsed.variables();
-  } catch {
-    return [];
-  }
-}
-var RELATION_REF_PATTERN = /\b([a-zA-Z_][a-zA-Z0-9_]*)\.([a-zA-Z_][a-zA-Z0-9_]*)\b/g;
-function extractRelationReferences(expression) {
-  const regex = new RegExp(RELATION_REF_PATTERN.source, "g");
-  const matches = expression.matchAll(regex);
-  return [...matches].map((m) => m[0]);
-}
-function extractRelationNames(expression) {
-  const refs = extractRelationReferences(expression);
-  const names = refs.map((ref) => ref.split(".")[0]);
-  return [...new Set(names)];
-}
-function hasRelationReferences(expression) {
-  const regex = new RegExp(RELATION_REF_PATTERN.source);
-  return regex.test(expression);
-}
-function flattenRelationsForEval(resolvedRelations) {
-  const result = {};
-  for (const [relationName, values] of Object.entries(resolvedRelations)) {
-    result[relationName] = { ...values };
-  }
-  return result;
-}
-
-// src/formula/path-parser.ts
-var InvalidPathError = class extends Error {
-  constructor(path, segment, reason) {
-    super(`Invalid path "${path}" at "${segment}": ${reason}`);
-    this.path = path;
-    this.segment = segment;
-    this.reason = reason;
-    this.name = "InvalidPathError";
-  }
-};
-var MaxDepthExceededError = class extends Error {
-  constructor(path, maxDepth) {
-    super(`Path "${path}" exceeds maximum depth of ${maxDepth}`);
-    this.path = path;
-    this.maxDepth = maxDepth;
-    this.name = "MaxDepthExceededError";
-  }
-};
-async function parsePath(path, startSchema, getSchema, maxDepth = 5) {
-  const segments = path.split(".");
-  if (segments.length === 0 || segments.length === 1 && segments[0] === "") {
-    throw new InvalidPathError(path, path, "Path cannot be empty");
-  }
-  if (segments.length > maxDepth) {
-    throw new MaxDepthExceededError(path, maxDepth);
-  }
-  const result = [];
-  let currentSchema = startSchema;
-  for (let i = 0; i < segments.length; i++) {
-    const segmentName = segments[i];
-    const isLastSegment = i === segments.length - 1;
-    const attr = currentSchema.attributes.find((a) => a.name === segmentName);
-    if (!attr) {
-      throw new InvalidPathError(
-        path,
-        segmentName,
-        `Attribute "${segmentName}" not found in object "${currentSchema.name}"`
-      );
-    }
-    if (attr.type === "relation") {
-      const relationAttr = attr;
-      const targetObject = relationAttr.targets[0]?.object;
-      if (!targetObject) {
-        throw new InvalidPathError(path, segmentName, "Relation has no target object");
-      }
-      result.push({
-        name: segmentName,
-        type: "relation",
-        cardinality: relationAttr.cardinality,
-        targetObject
-      });
-      if (!isLastSegment) {
-        const nextSchema = await getSchema(targetObject);
-        if (!nextSchema) {
-          throw new InvalidPathError(
-            path,
-            segmentName,
-            `Target object "${targetObject}" schema not found`
-          );
+    case "select":
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (item === null || item === void 0) continue;
+          const formatted = stringifyScalar(item);
+          if (formatted !== null) return formatted;
         }
-        currentSchema = nextSchema;
+        return null;
       }
-    } else {
-      if (!isLastSegment) {
-        throw new InvalidPathError(
-          path,
-          segmentName,
-          `"${segmentName}" is not a relation but has segments after it`
-        );
+      return stringifyScalar(value);
+    case "multiselect":
+      if (Array.isArray(value)) {
+        return value.flatMap((item) => {
+          if (item === null || item === void 0) return [];
+          const formatted = stringifyScalar(item);
+          return formatted === null ? [] : [formatted];
+        });
       }
-      result.push({ name: segmentName, type: "attribute" });
+      return stringifyScalar(value) === null ? [] : [String(value)];
+    default: {
+      const _exhaustive = returnType;
+      throw new Error(`Unsupported computed return type: ${_exhaustive}`);
     }
   }
-  return result;
-}
-async function validatePath(path, startSchema, getSchema, maxDepth = 5) {
-  try {
-    await parsePath(path, startSchema, getSchema, maxDepth);
-    return true;
-  } catch {
-    return false;
-  }
 }
-function pathHasManyCardinality(segments) {
-  return segments.some((s) => s.type === "relation" && s.cardinality === "many");
+function evaluateComputedAst(node, input) {
+  return evaluateAst(node, input);
 }
-function getPathDepth(segments) {
-  return segments.filter((s) => s.type === "relation").length;
+function evaluateComputedFormula(expression, input) {
+  return evaluateAst(parseComputedFormula(expression), input);
 }
-function getTargetAttributeName(path) {
-  const parts = path.split(".");
-  return parts[parts.length - 1];
-}
-function getRelationPath(path) {
-  const parts = path.split(".");
-  if (parts.length <= 1) return null;
-  return parts.slice(0, -1).join(".");
+function evaluateComputedFormulaWithResult(expression, input, returnType, decimals) {
+  try {
+    const raw = evaluateAst(parseComputedFormula(expression), input);
+    const value = returnType ? formatComputedResult(raw, returnType, decimals) : raw;
+    return { value };
+  } catch (error) {
+    return { value: null, error: error instanceof Error ? error.message : String(error) };
+  }
 }
 
+// src/computed/function-metadata.ts
+var COMPUTED_FUNCTION_METADATA = [
+  {
+    name: "if",
+    signature: "if(condition, then, else)",
+    description: "Conditional value",
+    category: "logic",
+    example: "if(amount > 100, 'big', 'small')"
+  },
+  {
+    name: "concat",
+    signature: "concat(a, b, ...)",
+    description: "Join values into text",
+    category: "text",
+    example: "concat(firstName, ' ', lastName)"
+  },
+  {
+    name: "sum",
+    signature: "sum(collection)",
+    description: "Total of values",
+    category: "number",
+    example: "sum(orders.amount)"
+  },
+  {
+    name: "avg",
+    signature: "avg(collection)",
+    description: "Average of values",
+    category: "number",
+    example: "avg(orders.amount)"
+  },
+  {
+    name: "min",
+    signature: "min(collection)",
+    description: "Smallest value",
+    category: "number",
+    example: "min(orders.amount)"
+  },
+  {
+    name: "max",
+    signature: "max(collection)",
+    description: "Largest value",
+    category: "number",
+    example: "max(orders.amount)"
+  },
+  {
+    name: "count",
+    signature: "count(collection)",
+    description: "Number of items",
+    category: "collection",
+    example: "count(orders)"
+  },
+  {
+    name: "count_empty",
+    signature: "count_empty(collection)",
+    description: "Items with no value",
+    category: "collection",
+    example: "count_empty(orders.note)"
+  },
+  {
+    name: "count_not_empty",
+    signature: "count_not_empty(collection)",
+    description: "Items with a value",
+    category: "collection",
+    example: "count_not_empty(orders.note)"
+  },
+  {
+    name: "count_unique",
+    signature: "count_unique(collection)",
+    description: "Distinct values",
+    category: "collection",
+    example: "count_unique(orders.status)"
+  },
+  {
+    name: "percent_empty",
+    signature: "percent_empty(collection)",
+    description: "Fraction with no value",
+    category: "collection",
+    example: "percent_empty(orders.note)"
+  },
+  {
+    name: "percent_not_empty",
+    signature: "percent_not_empty(collection)",
+    description: "Fraction with a value",
+    category: "collection",
+    example: "percent_not_empty(orders.note)"
+  },
+  {
+    name: "unique",
+    signature: "unique(collection)",
+    description: "Distinct values as a list",
+    category: "collection",
+    example: "unique(orders.status)"
+  },
+  {
+    name: "first",
+    signature: "first(collection)",
+    description: "First non-empty value",
+    category: "collection",
+    example: "first(orders.status)"
+  },
+  {
+    name: "earliest",
+    signature: "earliest(collection)",
+    description: "Earliest date",
+    category: "date",
+    example: "earliest(orders.closeDate)"
+  },
+  {
+    name: "latest",
+    signature: "latest(collection)",
+    description: "Latest date",
+    category: "date",
+    example: "latest(orders.closeDate)"
+  }
+];
+
 // src/filters/operators.ts
 var isEmpty = (v) => v === null || v === void 0 || v === "" || Array.isArray(v) && v.length === 0;
 var toStr = (v) => v == null ? "" : String(v);
@@ -5103,7 +6604,7 @@ var toNum = (v) => {
   const n = typeof v === "number" ? v : Number(v);
   return Number.isFinite(n) ? n : null;
 };
-var toDate = (v) => {
+var toDate2 = (v) => {
   if (v == null) return null;
   const d = v instanceof Date ? v : new Date(String(v));
   return Number.isNaN(d.getTime()) ? null : d;
@@ -5122,48 +6623,38 @@ function relativeDateBoundary(rel) {
 var OPERATOR_SPECS = {
   // ---- text-style ----
   is: {
-    appliesTo: ["text", "textarea", "phone", "status", "select", "date", "formula"],
+    appliesTo: ["text", "phone", "status", "select", "date", "formula"],
     evaluateInMemory: (v, rv) => toStr(v) === toStr(rv)
   },
   is_not: {
-    appliesTo: ["text", "textarea", "phone", "status", "select", "date", "formula"],
+    appliesTo: ["text", "phone", "status", "select", "date", "formula"],
     evaluateInMemory: (v, rv) => toStr(v) !== toStr(rv)
   },
   contains: {
-    appliesTo: [
-      "text",
-      "textarea",
-      "phone",
-      "location",
-      "user",
-      "multiselect",
-      "relation",
-      "formula"
-    ],
+    appliesTo: ["text", "phone", "location", "user", "multiselect", "relation", "formula"],
     evaluateInMemory: (v, rv) => {
       if (Array.isArray(v)) return v.map(toStr).includes(toStr(rv));
       return toStr(v).toLowerCase().includes(toStr(rv).toLowerCase());
     }
   },
   not_contains: {
-    appliesTo: ["text", "textarea", "phone", "user", "multiselect", "relation", "formula"],
+    appliesTo: ["text", "phone", "user", "multiselect", "relation", "formula"],
     evaluateInMemory: (v, rv) => {
       if (Array.isArray(v)) return !v.map(toStr).includes(toStr(rv));
       return !toStr(v).toLowerCase().includes(toStr(rv).toLowerCase());
     }
   },
   starts_with: {
-    appliesTo: ["text", "textarea", "formula"],
+    appliesTo: ["text", "formula"],
     evaluateInMemory: (v, rv) => toStr(v).toLowerCase().startsWith(toStr(rv).toLowerCase())
   },
   ends_with: {
-    appliesTo: ["text", "textarea", "formula"],
+    appliesTo: ["text", "formula"],
     evaluateInMemory: (v, rv) => toStr(v).toLowerCase().endsWith(toStr(rv).toLowerCase())
   },
   is_empty: {
     appliesTo: [
       "text",
-      "textarea",
       "richtext",
       "number",
       "phone",
@@ -5176,7 +6667,6 @@ var OPERATOR_SPECS = {
       "file",
       "user",
       "relation",
-      "rating",
       "formula",
       "document"
     ],
@@ -5185,7 +6675,6 @@ var OPERATOR_SPECS = {
   is_not_empty: {
     appliesTo: [
       "text",
-      "textarea",
       "richtext",
       "number",
       "phone",
@@ -5198,7 +6687,6 @@ var OPERATOR_SPECS = {
       "file",
       "user",
       "relation",
-      "rating",
       "formula",
       "document"
     ],
@@ -5206,15 +6694,15 @@ var OPERATOR_SPECS = {
   },
   // ---- numeric ----
   eq: {
-    appliesTo: ["number", "currency", "rating", "formula"],
+    appliesTo: ["number", "currency", "formula"],
     evaluateInMemory: (v, rv) => toNum(v) === toNum(rv)
   },
   neq: {
-    appliesTo: ["number", "currency", "rating", "formula"],
+    appliesTo: ["number", "currency", "formula"],
     evaluateInMemory: (v, rv) => toNum(v) !== toNum(rv)
   },
   lt: {
-    appliesTo: ["number", "currency", "rating", "formula"],
+    appliesTo: ["number", "currency", "formula"],
     evaluateInMemory: (v, rv) => {
       const a = toNum(v);
       const b = toNum(rv);
@@ -5222,7 +6710,7 @@ var OPERATOR_SPECS = {
     }
   },
   gt: {
-    appliesTo: ["number", "currency", "rating", "formula"],
+    appliesTo: ["number", "currency", "formula"],
     evaluateInMemory: (v, rv) => {
       const a = toNum(v);
       const b = toNum(rv);
@@ -5230,7 +6718,7 @@ var OPERATOR_SPECS = {
     }
   },
   lte: {
-    appliesTo: ["number", "currency", "rating", "formula"],
+    appliesTo: ["number", "currency", "formula"],
     evaluateInMemory: (v, rv) => {
       const a = toNum(v);
       const b = toNum(rv);
@@ -5238,7 +6726,7 @@ var OPERATOR_SPECS = {
     }
   },
   gte: {
-    appliesTo: ["number", "currency", "rating", "formula"],
+    appliesTo: ["number", "currency", "formula"],
     evaluateInMemory: (v, rv) => {
       const a = toNum(v);
       const b = toNum(rv);
@@ -5258,39 +6746,39 @@ var OPERATOR_SPECS = {
   before: {
     appliesTo: ["date"],
     evaluateInMemory: (v, rv) => {
-      const a = toDate(v);
-      const b = toDate(rv);
+      const a = toDate2(v);
+      const b = toDate2(rv);
       return a !== null && b !== null && a < b;
     }
   },
   after: {
     appliesTo: ["date"],
     evaluateInMemory: (v, rv) => {
-      const a = toDate(v);
-      const b = toDate(rv);
+      const a = toDate2(v);
+      const b = toDate2(rv);
       return a !== null && b !== null && a > b;
     }
   },
   on_or_before: {
     appliesTo: ["date"],
     evaluateInMemory: (v, rv) => {
-      const a = toDate(v);
-      const b = toDate(rv);
+      const a = toDate2(v);
+      const b = toDate2(rv);
       return a !== null && b !== null && a <= b;
     }
   },
   on_or_after: {
     appliesTo: ["date"],
     evaluateInMemory: (v, rv) => {
-      const a = toDate(v);
-      const b = toDate(rv);
+      const a = toDate2(v);
+      const b = toDate2(rv);
       return a !== null && b !== null && a >= b;
     }
   },
   is_within: {
     appliesTo: ["date"],
     evaluateInMemory: (v, rv) => {
-      const d = toDate(v);
+      const d = toDate2(v);
       if (!d) return false;
       const rel = rv;
       const boundary = relativeDateBoundary(rel);
@@ -5300,7 +6788,7 @@ var OPERATOR_SPECS = {
   day_month_eq: {
     appliesTo: ["date"],
     evaluateInMemory: (v, rv) => {
-      const d = toDate(v);
+      const d = toDate2(v);
       if (!d) return false;
       const rule = rv;
       return d.getMonth() + 1 === rule.month && d.getDate() === rule.day;
@@ -5398,7 +6886,7 @@ function assertOperatorForType(operator, type, context) {
   if (!ops?.includes(operator)) {
     const validList = ops?.length ? ops.join(", ") : "(no operators registered for this type)";
     const summary = `Operator "${operator}" is not valid for ${context} type "${type}". Valid operators: ${validList}.`;
-    throw new chunkFQ2ZYOVS_js.ValidationError(summary, [
+    throw new chunkMZOEL7FN_js.ValidationError(summary, [
       {
         path: ["operator"],
         message: summary
@@ -5410,43 +6898,45 @@ function validateQualifiedRule(rule, context) {
   const rootAttr = context.attributes.find((a) => a.name === rule.attribute);
   const systemOps = SYSTEM_FILTER_OPERATORS[rule.attribute];
   if (!(rootAttr || systemOps)) {
-    throw new chunkFQ2ZYOVS_js.ValidationError(`Unknown attribute: ${rule.attribute}`, [
+    throw new chunkMZOEL7FN_js.ValidationError(`Unknown attribute: ${rule.attribute}`, [
       { path: ["attribute"], message: `Unknown attribute: ${rule.attribute}` }
     ]);
   }
   if (!rootAttr) {
     if (rule.property) {
-      throw new chunkFQ2ZYOVS_js.ValidationError(`Cannot qualify system attribute "${rule.attribute}"`, [
+      throw new chunkMZOEL7FN_js.ValidationError(`Cannot qualify system attribute "${rule.attribute}"`, [
         { path: ["property"], message: `"${rule.attribute}" is a system column, not a reference` }
       ]);
     }
     if (!systemOps.includes(rule.operator)) {
       const summary = `Operator "${rule.operator}" is not valid for system attribute "${rule.attribute}". Valid operators: ${systemOps.join(", ")}.`;
-      throw new chunkFQ2ZYOVS_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
+      throw new chunkMZOEL7FN_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
     }
     return;
   }
   if (!rule.property) {
-    if (rootAttr.type === "rollup") {
-      return;
+    const ops = getAttributeFilterOperators(rootAttr);
+    if (!ops.includes(rule.operator)) {
+      const validList = ops.length ? ops.join(", ") : "(not filterable)";
+      const summary = `Operator "${rule.operator}" is not valid for attribute "${rootAttr.name}". Valid operators: ${validList}.`;
+      throw new chunkMZOEL7FN_js.ValidationError(summary, [{ path: ["operator"], message: summary }]);
     }
-    assertOperatorForType(rule.operator, rootAttr.type, "attribute");
     return;
   }
   if (!REFERENCE_TYPES.has(rootAttr.type)) {
-    throw new chunkFQ2ZYOVS_js.ValidationError(`Cannot qualify ${rootAttr.type} attribute "${rule.attribute}"`, [
+    throw new chunkMZOEL7FN_js.ValidationError(`Cannot qualify ${rootAttr.type} attribute "${rule.attribute}"`, [
       { path: ["property"], message: `Attribute "${rule.attribute}" is not a reference type` }
     ]);
   }
   const propSchema = rootAttr.properties;
   if (!propSchema) {
-    throw new chunkFQ2ZYOVS_js.ValidationError(`Attribute "${rule.attribute}" has no qualifyWith schema`, [
+    throw new chunkMZOEL7FN_js.ValidationError(`Attribute "${rule.attribute}" has no qualifyWith schema`, [
       { path: ["property"], message: `"${rule.attribute}" has no qualifyWith` }
     ]);
   }
   const propDef = propSchema.definitions.find((p) => p.name === rule.property);
   if (!propDef) {
-    throw new chunkFQ2ZYOVS_js.ValidationError(
+    throw new chunkMZOEL7FN_js.ValidationError(
       `Property "${rule.property}" not defined on "${rule.attribute}".qualifyWith()`,
       [{ path: ["property"], message: `Unknown property: ${rule.property}` }]
     );
@@ -5476,189 +6966,199 @@ Object.defineProperty(exports, "indexBy", {
 });
 Object.defineProperty(exports, "parseAttributeConfig", {
   enumerable: true,
-  get: function () { return chunkYQROI4IE_js.parseAttributeConfig; }
+  get: function () { return chunkM5QIBMIH_js.parseAttributeConfig; }
 });
 Object.defineProperty(exports, "AccessDeniedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.AccessDeniedError; }
+  get: function () { return chunkMZOEL7FN_js.AccessDeniedError; }
 });
 Object.defineProperty(exports, "AttributeInUseError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.AttributeInUseError; }
+  get: function () { return chunkMZOEL7FN_js.AttributeInUseError; }
 });
 Object.defineProperty(exports, "AttributeNotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.AttributeNotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.AttributeNotFoundError; }
 });
 Object.defineProperty(exports, "ChangeTypeNotSupportedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ChangeTypeNotSupportedError; }
+  get: function () { return chunkMZOEL7FN_js.ChangeTypeNotSupportedError; }
 });
 Object.defineProperty(exports, "ConcurrentModificationError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ConcurrentModificationError; }
+  get: function () { return chunkMZOEL7FN_js.ConcurrentModificationError; }
 });
 Object.defineProperty(exports, "DestructiveSyncNotAllowedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.DestructiveSyncNotAllowedError; }
+  get: function () { return chunkMZOEL7FN_js.DestructiveSyncNotAllowedError; }
 });
 Object.defineProperty(exports, "DuplicateError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.DuplicateError; }
+  get: function () { return chunkMZOEL7FN_js.DuplicateError; }
 });
 Object.defineProperty(exports, "ForbiddenError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ForbiddenError; }
+  get: function () { return chunkMZOEL7FN_js.ForbiddenError; }
 });
 Object.defineProperty(exports, "MemoryNotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.MemoryNotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.MemoryNotFoundError; }
 });
 Object.defineProperty(exports, "MigrationTimeoutError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.MigrationTimeoutError; }
+  get: function () { return chunkMZOEL7FN_js.MigrationTimeoutError; }
 });
 Object.defineProperty(exports, "NotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.NotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.NotFoundError; }
 });
 Object.defineProperty(exports, "NotImplementedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.NotImplementedError; }
+  get: function () { return chunkMZOEL7FN_js.NotImplementedError; }
 });
 Object.defineProperty(exports, "ObjectNotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ObjectNotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.ObjectNotFoundError; }
 });
 Object.defineProperty(exports, "ObjectReferencedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ObjectReferencedError; }
+  get: function () { return chunkMZOEL7FN_js.ObjectReferencedError; }
 });
 Object.defineProperty(exports, "OrphanSystemAttributeError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.OrphanSystemAttributeError; }
+  get: function () { return chunkMZOEL7FN_js.OrphanSystemAttributeError; }
 });
 Object.defineProperty(exports, "ProtectedResourceError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ProtectedResourceError; }
+  get: function () { return chunkMZOEL7FN_js.ProtectedResourceError; }
 });
 Object.defineProperty(exports, "ProtectedRoleError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ProtectedRoleError; }
+  get: function () { return chunkMZOEL7FN_js.ProtectedRoleError; }
 });
 Object.defineProperty(exports, "RecordNotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.RecordNotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.RecordNotFoundError; }
 });
 Object.defineProperty(exports, "RecordReferencedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.RecordReferencedError; }
+  get: function () { return chunkMZOEL7FN_js.RecordReferencedError; }
 });
 Object.defineProperty(exports, "RepositoryError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.RepositoryError; }
+  get: function () { return chunkMZOEL7FN_js.RepositoryError; }
 });
 Object.defineProperty(exports, "RoleNotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.RoleNotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.RoleNotFoundError; }
 });
 Object.defineProperty(exports, "SchemaError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.SchemaError; }
+  get: function () { return chunkMZOEL7FN_js.SchemaError; }
 });
 Object.defineProperty(exports, "SchemaErrorCode", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.SchemaErrorCode; }
+  get: function () { return chunkMZOEL7FN_js.SchemaErrorCode; }
 });
 Object.defineProperty(exports, "StorageError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.StorageError; }
+  get: function () { return chunkMZOEL7FN_js.StorageError; }
 });
 Object.defineProperty(exports, "SyncCascadeError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.SyncCascadeError; }
+  get: function () { return chunkMZOEL7FN_js.SyncCascadeError; }
 });
 Object.defineProperty(exports, "SyncConflictError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.SyncConflictError; }
+  get: function () { return chunkMZOEL7FN_js.SyncConflictError; }
 });
 Object.defineProperty(exports, "SyncError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.SyncError; }
+  get: function () { return chunkMZOEL7FN_js.SyncError; }
 });
 Object.defineProperty(exports, "SystemEntityImmutableError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.SystemEntityImmutableError; }
+  get: function () { return chunkMZOEL7FN_js.SystemEntityImmutableError; }
 });
 Object.defineProperty(exports, "ValidationError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.ValidationError; }
+  get: function () { return chunkMZOEL7FN_js.ValidationError; }
 });
 Object.defineProperty(exports, "computeRecordStatus", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.computeRecordStatus; }
+  get: function () { return chunkMZOEL7FN_js.computeRecordStatus; }
 });
 Object.defineProperty(exports, "createFormAttributeValidator", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.createFormAttributeValidator; }
+  get: function () { return chunkMZOEL7FN_js.createFormAttributeValidator; }
 });
 Object.defineProperty(exports, "isAttributeInUseError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isAttributeInUseError; }
+  get: function () { return chunkMZOEL7FN_js.isAttributeInUseError; }
 });
 Object.defineProperty(exports, "isNotFoundError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isNotFoundError; }
+  get: function () { return chunkMZOEL7FN_js.isNotFoundError; }
 });
 Object.defineProperty(exports, "isObjectReferencedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isObjectReferencedError; }
+  get: function () { return chunkMZOEL7FN_js.isObjectReferencedError; }
 });
 Object.defineProperty(exports, "isProtectedResourceError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isProtectedResourceError; }
+  get: function () { return chunkMZOEL7FN_js.isProtectedResourceError; }
 });
 Object.defineProperty(exports, "isRecordReferencedError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isRecordReferencedError; }
+  get: function () { return chunkMZOEL7FN_js.isRecordReferencedError; }
 });
 Object.defineProperty(exports, "isSchemaError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isSchemaError; }
+  get: function () { return chunkMZOEL7FN_js.isSchemaError; }
 });
 Object.defineProperty(exports, "isValidationError", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.isValidationError; }
+  get: function () { return chunkMZOEL7FN_js.isValidationError; }
+});
+Object.defineProperty(exports, "rejectUnknownAttributesOrThrow", {
+  enumerable: true,
+  get: function () { return chunkMZOEL7FN_js.rejectUnknownAttributesOrThrow; }
 });
 Object.defineProperty(exports, "validateDraft", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.validateDraft; }
+  get: function () { return chunkMZOEL7FN_js.validateDraft; }
 });
 Object.defineProperty(exports, "validateDraftOrThrow", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.validateDraftOrThrow; }
+  get: function () { return chunkMZOEL7FN_js.validateDraftOrThrow; }
 });
 Object.defineProperty(exports, "validateObject", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.validateObject; }
+  get: function () { return chunkMZOEL7FN_js.validateObject; }
 });
 Object.defineProperty(exports, "validateObjectOrThrow", {
   enumerable: true,
-  get: function () { return chunkFQ2ZYOVS_js.validateObjectOrThrow; }
+  get: function () { return chunkMZOEL7FN_js.validateObjectOrThrow; }
 });
 Object.defineProperty(exports, "DEFAULT_VALIDATION_MESSAGES", {
   enumerable: true,
-  get: function () { return chunkT225DB55_js.DEFAULT_VALIDATION_MESSAGES; }
+  get: function () { return chunkYKWSHBT5_js.DEFAULT_VALIDATION_MESSAGES; }
 });
 Object.defineProperty(exports, "formatZodErrors", {
   enumerable: true,
-  get: function () { return chunkT225DB55_js.formatZodErrors; }
+  get: function () { return chunkYKWSHBT5_js.formatZodErrors; }
 });
 exports.ALLOWED_PROPERTY_TYPES = ALLOWED_PROPERTY_TYPES;
 exports.ALL_ACTIONS = ALL_ACTIONS;
 exports.ALL_SYSTEM_RESOURCES = ALL_SYSTEM_RESOURCES;
+exports.ATTRIBUTE_FILTER_OPERATORS = ATTRIBUTE_FILTER_OPERATORS;
 exports.ActivityTabConfig = ActivityTabConfig;
 exports.BEHAVIOR_PROPERTIES = BEHAVIOR_PROPERTIES;
+exports.COMPUTED_FUNCTIONS = COMPUTED_FUNCTIONS;
+exports.COMPUTED_FUNCTION_METADATA = COMPUTED_FUNCTION_METADATA;
+exports.COMPUTED_FUNCTION_NAMES = COMPUTED_FUNCTION_NAMES;
+exports.ComputedFormulaCompileError = ComputedFormulaCompileError;
+exports.ComputedFormulaParseError = ComputedFormulaParseError;
 exports.CustomTabConfig = CustomTabConfig;
 exports.DB_COLUMN_FIELDS = DB_COLUMN_FIELDS;
 exports.DEFAULT_DOCUMENT_SLOT = DEFAULT_DOCUMENT_SLOT;
@@ -5680,11 +7180,11 @@ exports.FormRowBuilder = FormRowBuilder;
 exports.FormStepBuilder = FormStepBuilder;
 exports.GroupBuilder = GroupBuilder;
 exports.IDENTITY_PROPERTIES = IDENTITY_PROPERTIES;
-exports.InvalidPathError = InvalidPathError;
+exports.LIVE_EVENT_TYPES = LIVE_EVENT_TYPES;
+exports.LIVE_STREAM_START_CURSOR = LIVE_STREAM_START_CURSOR;
 exports.ListViewBuilder = ListViewBuilder;
 exports.ListViewTabConfigBuilder = ListViewTabConfigBuilder;
 exports.MAX_PRESET_DEPTH = MAX_PRESET_DEPTH;
-exports.MaxDepthExceededError = MaxDepthExceededError;
 exports.NO_VALUE_OPERATORS = NO_VALUE_OPERATORS;
 exports.NoopGeocodingAdapter = NoopGeocodingAdapter;
 exports.OPERATORS_BY_TYPE = OPERATORS_BY_TYPE;
@@ -5708,10 +7208,15 @@ exports.USER_STATUSES = USER_STATUSES;
 exports.accessLevelToActions = accessLevelToActions;
 exports.actionsToAccessLevel = actionsToAccessLevel;
 exports.applyPipes = applyPipes;
+exports.assertAcyclicComputedDependencies = assertAcyclicComputedDependencies;
+exports.assertLiveStreamCursor = assertLiveStreamCursor;
 exports.booleanFlag = booleanFlag;
 exports.buildPropertySchema = buildPropertySchema;
 exports.buildQualifiedAttribute = buildQualifiedAttribute;
 exports.checkbox = checkbox;
+exports.compareLiveStreamCursors = compareLiveStreamCursors;
+exports.compileComputedFormula = compileComputedFormula;
+exports.compileRollupAttribute = compileRollupAttribute;
 exports.createFlagRegistry = createFlagRegistry;
 exports.createFlagService = createFlagService;
 exports.createStandardSchemaProps = createStandardSchemaProps;
@@ -5719,39 +7224,40 @@ exports.currency = currency;
 exports.date = date;
 exports.detailView = detailView;
 exports.document = document;
+exports.evaluateComputedAst = evaluateComputedAst;
+exports.evaluateComputedFormula = evaluateComputedFormula;
+exports.evaluateComputedFormulaWithResult = evaluateComputedFormulaWithResult;
 exports.evaluateFilterState = evaluateFilterState;
-exports.evaluateFormula = evaluateFormula;
-exports.evaluateFormulaAttribute = evaluateFormulaAttribute;
-exports.evaluateFormulaWithResult = evaluateFormulaWithResult;
 exports.extractAttributeNames = extractAttributeNames;
-exports.extractFormulaVariables = extractFormulaVariables;
-exports.extractRelationNames = extractRelationNames;
-exports.extractRelationReferences = extractRelationReferences;
 exports.file = file;
 exports.flagRegistry = flagRegistry;
-exports.flattenRelationsForEval = flattenRelationsForEval;
 exports.form = form;
 exports.formRegistry = formRegistry;
 exports.formatAttributeValue = formatAttributeValue;
-exports.formatFormulaResult = formatFormulaResult;
+exports.formatComputedResult = formatComputedResult;
 exports.formula = formula;
 exports.generateDefaultDetailView = generateDefaultDetailView;
 exports.generateDefaultListView = generateDefaultListView;
 exports.getActiveTab = getActiveTab;
+exports.getAttributeCapabilities = getAttributeCapabilities;
+exports.getAttributeFilterOperators = getAttributeFilterOperators;
 exports.getErrorMessage = getErrorMessage;
+exports.getLiveProtocolPayloadChannel = getLiveProtocolPayloadChannel;
 exports.getOperatorPolarity = getOperatorPolarity;
-exports.getPathDepth = getPathDepth;
-exports.getRelationPath = getRelationPath;
-exports.getRollupFilterOperators = getRollupFilterOperators;
+exports.getRollupFilterOperators = getRollupFilterOperators2;
 exports.getSystemAttributeI18nKey = getSystemAttributeI18nKey;
 exports.getSystemAttributeList = getSystemAttributeList;
-exports.getTargetAttributeName = getTargetAttributeName;
 exports.group = group;
 exports.hasOptions = hasOptions;
-exports.hasRelationReferences = hasRelationReferences;
 exports.inferInverseCardinality = inferInverseCardinality;
-exports.isAttributeSortable = isAttributeSortable;
+exports.inferRollupReturnType = inferRollupReturnType;
+exports.isAttributeFilterable = isAttributeFilterable;
+exports.isAttributeGroupable = isAttributeGroupable;
+exports.isAttributeKanbanGroupable = isAttributeKanbanGroupable;
+exports.isAttributeSearchable = isAttributeSearchable;
+exports.isAttributeSortable = isAttributeSortable2;
 exports.isBilateralRelation = isBilateralRelation;
+exports.isComputedFunctionName = isComputedFunctionName;
 exports.isDefaultRole = isDefaultRole;
 exports.isDetailView = isDetailView;
 exports.isDocumentAttribute = isDocumentAttribute;
@@ -5766,13 +7272,23 @@ exports.isFormSlotFieldRef = isFormSlotFieldRef;
 exports.isFormTextRow = isFormTextRow;
 exports.isLabelExpression = isLabelExpression;
 exports.isListView = isListView;
+exports.isLiveErrorPayload = isLiveErrorPayload;
+exports.isLiveEventEnvelope = isLiveEventEnvelope;
+exports.isLiveEventPayload = isLiveEventPayload;
+exports.isLiveEventPayloadForType = isLiveEventPayloadForType;
+exports.isLiveEventType = isLiveEventType;
+exports.isLiveGapPayload = isLiveGapPayload;
+exports.isLiveReplayCompletePayload = isLiveReplayCompletePayload;
+exports.isLiveStreamCursor = isLiveStreamCursor;
 exports.isNoValueOperator = isNoValueOperator;
 exports.isNotEmpty = isNotEmpty;
+exports.isPlainRecord = isPlainRecord;
 exports.isRelationGroup = isRelationGroup;
 exports.isStandardSchema = isStandardSchema;
 exports.isUniversalRelation = isUniversalRelation;
 exports.jsonFlag = jsonFlag;
 exports.listView = listView;
+exports.liveChannelKey = liveChannelKey;
 exports.location = location;
 exports.matchesMime = matchesMime;
 exports.multiselect = multiselect;
@@ -5781,11 +7297,12 @@ exports.normalizeForEdgeRpc = normalizeForEdgeRpc;
 exports.number = number;
 exports.numberFlag = numberFlag;
 exports.object = object;
-exports.parsePath = parsePath;
+exports.parseComputedFormula = parseComputedFormula;
+exports.parseLiveChannelKey = parseLiveChannelKey;
+exports.parseLiveSubscribePayload = parseLiveSubscribePayload;
+exports.parseLiveUnsubscribePayload = parseLiveUnsubscribePayload;
 exports.parseQualifiedAttribute = parseQualifiedAttribute;
-exports.pathHasManyCardinality = pathHasManyCardinality;
 exports.phone = phone;
-exports.rating = rating;
 exports.registry = registry;
 exports.relation = relation;
 exports.relationGroup = relationGroup;
@@ -5793,16 +7310,14 @@ exports.renderLabelExpression = renderLabelExpression;
 exports.resetViewToDefault = resetViewToDefault;
 exports.richtext = richtext;
 exports.rollup = rollup;
+exports.rollupToFormulaExpression = rollupToFormulaExpression;
 exports.select = select;
 exports.status = status;
 exports.stringFlag = stringFlag;
 exports.text = text;
-exports.textarea = textarea;
 exports.toUndefinedIfEmpty = toUndefinedIfEmpty;
 exports.user = user;
 exports.validateAttributeName = validateAttributeName;
-exports.validateFormulaExpression = validateFormulaExpression;
-exports.validatePath = validatePath;
 exports.validateQualifiedRule = validateQualifiedRule;
 exports.validateSlotAgainstConfig = validateSlotAgainstConfig;
 exports.viewRegistry = viewRegistry;