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

package/dist/index.mjs

@@ -1,34 +1,31 @@
 import { generateId } from './chunk-QY6QFRRV.mjs';
 export { asTenantId, asUserId, deepEqual, generateId, indexBy } from './chunk-QY6QFRRV.mjs';
 import './chunk-SP3PNHYF.mjs';
-export { parseAttributeConfig } from './chunk-U4JC7P6D.mjs';
-import { createObjectValidator, SchemaError, SchemaErrorCode, ValidationError, createAttributeValidator } from './chunk-LTHSU4NF.mjs';
-export { AccessDeniedError, AttributeInUseError, AttributeNotFoundError, ChangeTypeNotSupportedError, ConcurrentModificationError, DestructiveSyncNotAllowedError, DuplicateError, ForbiddenError, MemoryNotFoundError, MigrationTimeoutError, NotFoundError, NotImplementedError, ObjectNotFoundError, ObjectReferencedError, OrphanSystemAttributeError, ProtectedResourceError, ProtectedRoleError, RecordNotFoundError, RecordReferencedError, RepositoryError, RoleNotFoundError, SchemaError, SchemaErrorCode, StorageError, SyncCascadeError, SyncConflictError, SyncError, SystemEntityImmutableError, ValidationError, computeRecordStatus, createFormAttributeValidator, isAttributeInUseError, isNotFoundError, isObjectReferencedError, isProtectedResourceError, isRecordReferencedError, isSchemaError, isValidationError, validateDraft, validateDraftOrThrow, validateObject, validateObjectOrThrow } from './chunk-LTHSU4NF.mjs';
-import './chunk-TMYBEXBT.mjs';
-import './chunk-4KRLCWJM.mjs';
-import './chunk-KNYZH2WD.mjs';
-import './chunk-RUYUFXNW.mjs';
-import './chunk-KWVCGQ7N.mjs';
-import './chunk-BLXQGQLK.mjs';
-import './chunk-SMOHDR6M.mjs';
-import './chunk-ITTQ4FGR.mjs';
-import './chunk-IRTRJH37.mjs';
-import './chunk-OLJLCVNY.mjs';
-import './chunk-TEQNVO7W.mjs';
-import './chunk-4TC27SMF.mjs';
-import './chunk-TBYXYSGA.mjs';
-import { formatPhoneForDisplay } from './chunk-Z75P63VF.mjs';
-import './chunk-R4CJHCC4.mjs';
-export { DEFAULT_VALIDATION_MESSAGES, formatZodErrors } from './chunk-UQVW4KPP.mjs';
+export { parseAttributeConfig } from './chunk-HXDDJLHD.mjs';
+import { createObjectValidator, SchemaError, SchemaErrorCode, ValidationError, createAttributeValidator } from './chunk-PMKCDRRO.mjs';
+export { AccessDeniedError, AttributeInUseError, AttributeNotFoundError, ChangeTypeNotSupportedError, ConcurrentModificationError, DestructiveSyncNotAllowedError, DuplicateError, ForbiddenError, MemoryNotFoundError, MigrationTimeoutError, NotFoundError, NotImplementedError, ObjectNotFoundError, ObjectReferencedError, OrphanSystemAttributeError, ProtectedResourceError, ProtectedRoleError, RecordNotFoundError, RecordReferencedError, RepositoryError, RoleNotFoundError, SchemaError, SchemaErrorCode, StorageError, SyncCascadeError, SyncConflictError, SyncError, SystemEntityImmutableError, ValidationError, computeRecordStatus, createFormAttributeValidator, isAttributeInUseError, isNotFoundError, isObjectReferencedError, isProtectedResourceError, isRecordReferencedError, isSchemaError, isValidationError, rejectUnknownAttributesOrThrow, validateDraft, validateDraftOrThrow, validateObject, validateObjectOrThrow } from './chunk-PMKCDRRO.mjs';
+import './chunk-OSSGN43B.mjs';
+import './chunk-6I2R22CX.mjs';
+import './chunk-UANQJ2GH.mjs';
+import './chunk-NOMHDOVE.mjs';
+import './chunk-QVLQPW3O.mjs';
+import './chunk-ZDQ5AP26.mjs';
+import './chunk-ZDMOXF3U.mjs';
+import './chunk-UXAHLSWC.mjs';
+import './chunk-NS63SPNN.mjs';
+import './chunk-AYVHMVKQ.mjs';
+import './chunk-QEZUDVTN.mjs';
+import './chunk-YUFTHPOE.mjs';
+import { formatPhoneForDisplay } from './chunk-JUKLL5RJ.mjs';
+import './chunk-XZ5RG2OG.mjs';
+export { DEFAULT_VALIDATION_MESSAGES, formatZodErrors } from './chunk-HRQEZUAA.mjs';
 import { ICONS, getCountryDisplayNameByIso3 } from '@stndrds/constants';
 import z3, { z } from 'zod';
-import { Parser } from 'expr-eval';
 
 // src/types/attribute-protection.ts
 var IDENTITY_PROPERTIES = ["name", "type"];
 var BEHAVIOR_PROPERTIES = [
   "required",
-  "disabled",
   "hidden",
   "archived",
   "deprecated",
@@ -39,6 +36,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) {
@@ -50,17 +359,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
@@ -82,95 +382,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",
@@ -180,19 +392,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
@@ -310,7 +511,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Created time",
     type: "date",
     required: false,
-    disabled: true,
     system: true,
     icon: "clock-circle",
     description: "When this record was created"
@@ -321,7 +521,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"
@@ -332,7 +531,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Created by",
     type: "user",
     required: false,
-    disabled: true,
     system: true,
     multiple: false,
     icon: "user",
@@ -344,7 +542,6 @@ var SYSTEM_ATTRIBUTES = {
     label: "Last edited by",
     type: "user",
     required: false,
-    disabled: true,
     system: true,
     multiple: false,
     icon: "user",
@@ -361,8 +558,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
@@ -458,7 +653,6 @@ function validateSlotAgainstConfig(slotName, mimeType, slots) {
 // src/lib/qualify-with.ts
 var ALLOWED_PROPERTY_TYPES = Object.freeze([
   "text",
-  "textarea",
   "number",
   "checkbox",
   "date",
@@ -467,7 +661,6 @@ var ALLOWED_PROPERTY_TYPES = Object.freeze([
   "status",
   "select",
   "multiselect",
-  "rating",
   "location"
 ]);
 function buildPropertySchema(builders) {
@@ -507,6 +700,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, {
@@ -608,18 +804,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);
@@ -638,8 +828,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":
@@ -983,41 +1171,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;
@@ -1121,10 +1293,6 @@ var BaseAttributeBuilder = class {
     this.attr.system = false;
     return this;
   }
-  disabled() {
-    this.attr.disabled = true;
-    return this;
-  }
   hidden() {
     this.attr.hidden = true;
     return this;
@@ -1156,32 +1324,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;
   }
@@ -1202,6 +1344,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();
@@ -1235,42 +1381,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();
@@ -1309,6 +1423,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();
@@ -1422,7 +1540,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();
   }
@@ -1431,7 +1549,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;
   }
@@ -1456,7 +1574,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();
   }
@@ -1465,7 +1583,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;
   }
@@ -1490,7 +1608,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();
   }
@@ -1499,7 +1617,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;
   }
@@ -1523,14 +1641,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;
@@ -1539,10 +1649,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();
@@ -1593,9 +1699,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;
   }
   /**
@@ -1706,18 +1817,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() {
@@ -1739,13 +1843,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
    */
@@ -1765,30 +1862,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);
@@ -1912,20 +1985,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.
@@ -1934,38 +1993,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.
@@ -2301,11 +2328,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"
   };
@@ -2410,6 +2435,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,
@@ -2470,6 +2497,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
    *
@@ -2622,7 +2686,9 @@ var ObjectBuilder = class {
       pluralLabel: this._pluralLabel,
       labelExpression: this._labelExpression,
       schema_version,
-      migrations: sortedVersions
+      migrations: sortedVersions,
+      sealed: this._sealed,
+      toleratedAttributes: this._toleratedAttributes
     };
   }
   /**
@@ -4511,9 +4577,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) {
@@ -4524,9 +4590,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;
@@ -4539,7 +4605,7 @@ function getDefaultFieldSpan(type) {
 function attributeToField(attr) {
   return {
     attribute: attr.name,
-    span: getDefaultFieldSpan(attr.type)
+    span: getDefaultFieldSpan(attr)
   };
 }
 function generateDefaultDetailView(object2, options = {}) {
@@ -4549,8 +4615,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",
@@ -4605,8 +4673,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: [
@@ -4648,289 +4718,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 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;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
   }
-  return maxDepth;
+  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 isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function formatFormulaResult(value, returnType, decimals) {
+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);
@@ -4945,152 +6435,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 getPathDepth(segments) {
-  return segments.filter((s) => s.type === "relation").length;
+function evaluateComputedAst(node, input) {
+  return evaluateAst(node, input);
 }
-function getTargetAttributeName(path) {
-  const parts = path.split(".");
-  return parts[parts.length - 1];
+function evaluateComputedFormula(expression, input) {
+  return evaluateAst(parseComputedFormula(expression), input);
 }
-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);
@@ -5099,7 +6600,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;
@@ -5118,48 +6619,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",
@@ -5172,7 +6663,6 @@ var OPERATOR_SPECS = {
       "file",
       "user",
       "relation",
-      "rating",
       "formula",
       "document"
     ],
@@ -5181,7 +6671,6 @@ var OPERATOR_SPECS = {
   is_not_empty: {
     appliesTo: [
       "text",
-      "textarea",
       "richtext",
       "number",
       "phone",
@@ -5194,7 +6683,6 @@ var OPERATOR_SPECS = {
       "file",
       "user",
       "relation",
-      "rating",
       "formula",
       "document"
     ],
@@ -5202,15 +6690,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);
@@ -5218,7 +6706,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);
@@ -5226,7 +6714,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);
@@ -5234,7 +6722,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);
@@ -5254,39 +6742,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);
@@ -5296,7 +6784,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;
@@ -5423,10 +6911,12 @@ function validateQualifiedRule(rule, context) {
     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 ValidationError(summary, [{ path: ["operator"], message: summary }]);
     }
-    assertOperatorForType(rule.operator, rootAttr.type, "attribute");
     return;
   }
   if (!REFERENCE_TYPES.has(rootAttr.type)) {
@@ -5450,4 +6940,4 @@ function validateQualifiedRule(rule, context) {
   assertOperatorForType(rule.operator, propDef.type, "property");
 }
 
-export { ALLOWED_PROPERTY_TYPES, ALL_ACTIONS, ALL_SYSTEM_RESOURCES, ActivityTabConfig, BEHAVIOR_PROPERTIES, CustomTabConfig, DB_COLUMN_FIELDS, DEFAULT_DOCUMENT_SLOT, DEFAULT_ROLES, DEFAULT_ROLE_DESCRIPTIONS, DEFAULT_ROLE_LABELS, DEFAULT_ROLE_PERMISSIONS, DOCUMENT_SYSTEM_ATTRIBUTES, DetailViewBuilder, DocumentSlotValidationError, DocumentsTabConfig, EMPTY_VALUE_PLACEHOLDER, FORM_FORBIDDEN_ATTRIBUTE_TYPES, FlagRegistry, FlagService, FormBuilder, FormRegistry, FormRowBuilder, FormStepBuilder, GroupBuilder, IDENTITY_PROPERTIES, InvalidPathError, ListViewBuilder, ListViewTabConfigBuilder, MAX_PRESET_DEPTH, MaxDepthExceededError, NO_VALUE_OPERATORS, NoopGeocodingAdapter, OPERATORS_BY_TYPE, OPERATOR_SPECS, ObjectBuilder, PRESENTATION_PROPERTIES, QUALIFIED_SEPARATOR, RELATION_TARGET_ANY, RESERVED_ATTRIBUTE_NAMES, RelationGroupBuilder, RichtextTabConfig, STANDARD_SCHEMA_VENDOR, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FIELD_NAMES, SYSTEM_RESOURCES, SYSTEM_RESOURCE_LABELS, TabBuilder, TableTabConfig, USER_STATUSES, accessLevelToActions, actionsToAccessLevel, applyPipes, booleanFlag, buildPropertySchema, buildQualifiedAttribute, checkbox, createFlagRegistry, createFlagService, createStandardSchemaProps, currency, date, detailView, document, evaluateFilterState, evaluateFormula, evaluateFormulaAttribute, evaluateFormulaWithResult, extractAttributeNames, extractFormulaVariables, extractRelationNames, extractRelationReferences, file, flagRegistry, flattenRelationsForEval, form, formRegistry, formatAttributeValue, formatFormulaResult, formula, generateDefaultDetailView, generateDefaultListView, getActiveTab, getErrorMessage, getOperatorPolarity, getPathDepth, getRelationPath, getRollupFilterOperators, getSystemAttributeI18nKey, getSystemAttributeList, getTargetAttributeName, group, hasOptions, hasRelationReferences, inferInverseCardinality, isAttributeSortable, isBilateralRelation, isDefaultRole, isDetailView, isDocumentAttribute, isEmptyObject, isFieldGroup, isFormDefinition, isFormFieldsRow, isFormFreeFieldRef, isFormHeadingRow, isFormSeparatorRow, isFormSlotFieldRef, isFormTextRow, isLabelExpression, isListView, isNoValueOperator, isNotEmpty, isRelationGroup, isStandardSchema, isUniversalRelation, jsonFlag, listView, location, matchesMime, multiselect, normaliseDocumentSlots, normalizeForEdgeRpc, number, numberFlag, object, parsePath, parseQualifiedAttribute, pathHasManyCardinality, phone, rating, registry, relation, relationGroup, renderLabelExpression, resetViewToDefault, richtext, rollup, select, status, stringFlag, text, textarea, toUndefinedIfEmpty, user, validateAttributeName, validateFormulaExpression, validatePath, validateQualifiedRule, validateSlotAgainstConfig, viewRegistry };
+export { ALLOWED_PROPERTY_TYPES, ALL_ACTIONS, ALL_SYSTEM_RESOURCES, ATTRIBUTE_FILTER_OPERATORS, ActivityTabConfig, BEHAVIOR_PROPERTIES, COMPUTED_FUNCTIONS, COMPUTED_FUNCTION_METADATA, COMPUTED_FUNCTION_NAMES, ComputedFormulaCompileError, ComputedFormulaParseError, CustomTabConfig, DB_COLUMN_FIELDS, DEFAULT_DOCUMENT_SLOT, DEFAULT_ROLES, DEFAULT_ROLE_DESCRIPTIONS, DEFAULT_ROLE_LABELS, DEFAULT_ROLE_PERMISSIONS, DOCUMENT_SYSTEM_ATTRIBUTES, DetailViewBuilder, DocumentSlotValidationError, DocumentsTabConfig, EMPTY_VALUE_PLACEHOLDER, FORM_FORBIDDEN_ATTRIBUTE_TYPES, FlagRegistry, FlagService, FormBuilder, FormRegistry, FormRowBuilder, FormStepBuilder, GroupBuilder, IDENTITY_PROPERTIES, LIVE_EVENT_TYPES, LIVE_STREAM_START_CURSOR, ListViewBuilder, ListViewTabConfigBuilder, MAX_PRESET_DEPTH, NO_VALUE_OPERATORS, NoopGeocodingAdapter, OPERATORS_BY_TYPE, OPERATOR_SPECS, ObjectBuilder, PRESENTATION_PROPERTIES, QUALIFIED_SEPARATOR, RELATION_TARGET_ANY, RESERVED_ATTRIBUTE_NAMES, RelationGroupBuilder, RichtextTabConfig, STANDARD_SCHEMA_VENDOR, SYSTEM_ATTRIBUTES, SYSTEM_ATTRIBUTE_I18N_KEYS, SYSTEM_FIELD_NAMES, SYSTEM_RESOURCES, SYSTEM_RESOURCE_LABELS, TabBuilder, TableTabConfig, USER_STATUSES, accessLevelToActions, actionsToAccessLevel, applyPipes, assertAcyclicComputedDependencies, assertLiveStreamCursor, booleanFlag, buildPropertySchema, buildQualifiedAttribute, checkbox, compareLiveStreamCursors, compileComputedFormula, compileRollupAttribute, createFlagRegistry, createFlagService, createStandardSchemaProps, currency, date, detailView, document, evaluateComputedAst, evaluateComputedFormula, evaluateComputedFormulaWithResult, evaluateFilterState, extractAttributeNames, file, flagRegistry, form, formRegistry, formatAttributeValue, formatComputedResult, formula, generateDefaultDetailView, generateDefaultListView, getActiveTab, getAttributeCapabilities, getAttributeFilterOperators, getErrorMessage, getLiveProtocolPayloadChannel, getOperatorPolarity, getRollupFilterOperators2 as getRollupFilterOperators, getSystemAttributeI18nKey, getSystemAttributeList, group, hasOptions, inferInverseCardinality, inferRollupReturnType, isAttributeFilterable, isAttributeGroupable, isAttributeKanbanGroupable, isAttributeSearchable, isAttributeSortable2 as isAttributeSortable, isBilateralRelation, isComputedFunctionName, isDefaultRole, isDetailView, isDocumentAttribute, isEmptyObject, isFieldGroup, isFormDefinition, isFormFieldsRow, isFormFreeFieldRef, isFormHeadingRow, isFormSeparatorRow, isFormSlotFieldRef, isFormTextRow, isLabelExpression, isListView, isLiveErrorPayload, isLiveEventEnvelope, isLiveEventPayload, isLiveEventPayloadForType, isLiveEventType, isLiveGapPayload, isLiveReplayCompletePayload, isLiveStreamCursor, isNoValueOperator, isNotEmpty, isPlainRecord, isRelationGroup, isStandardSchema, isUniversalRelation, jsonFlag, listView, liveChannelKey, location, matchesMime, multiselect, normaliseDocumentSlots, normalizeForEdgeRpc, number, numberFlag, object, parseComputedFormula, parseLiveChannelKey, parseLiveSubscribePayload, parseLiveUnsubscribePayload, parseQualifiedAttribute, phone, registry, relation, relationGroup, renderLabelExpression, resetViewToDefault, richtext, rollup, rollupToFormulaExpression, select, status, stringFlag, text, toUndefinedIfEmpty, user, validateAttributeName, validateQualifiedRule, validateSlotAgainstConfig, viewRegistry };