@stndrds/schema 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/index.js

@@ -59,21 +59,25 @@ var init_default_roles = __esm({
       /** Tenant settings and configuration */
       SETTINGS: "settings",
       /** Audit logs and activity trail */
-      AUDIT: "audit"
+      AUDIT: "audit",
+      /** File uploads and storage management */
+      FILES: "files"
     };
     ALL_SYSTEM_RESOURCES = [
       SYSTEM_RESOURCES.USERS,
       SYSTEM_RESOURCES.SCHEMA,
       SYSTEM_RESOURCES.ROLES,
       SYSTEM_RESOURCES.SETTINGS,
-      SYSTEM_RESOURCES.AUDIT
+      SYSTEM_RESOURCES.AUDIT,
+      SYSTEM_RESOURCES.FILES
     ];
     SYSTEM_RESOURCE_LABELS = {
       users: "Users",
       schema: "Schema",
       roles: "Roles & Permissions",
       settings: "Settings",
-      audit: "Audit Logs"
+      audit: "Audit Logs",
+      files: "Files"
     };
     DEFAULT_ROLES = {
       /** Full platform access - can manage everything */
@@ -140,6 +144,8 @@ __export(index_exports, {
   GeocodingService: () => GeocodingService,
   GlobalSearchService: () => GlobalSearchService,
   GroupBuilder: () => GroupBuilder,
+  InvalidPathError: () => InvalidPathError,
+  MaxDepthExceededError: () => MaxDepthExceededError,
   NO_VALUE_OPERATORS: () => NO_VALUE_OPERATORS,
   NoopGeocodingAdapter: () => NoopGeocodingAdapter,
   NoopHookRegistry: () => NoopHookRegistry,
@@ -156,8 +162,11 @@ __export(index_exports, {
   RecordNotFoundError: () => RecordNotFoundError,
   RecordReferencedError: () => RecordReferencedError,
   RecordService: () => RecordService,
+  RelationResolverService: () => RelationResolverService,
   RelationService: () => RelationService,
   RoleNotFoundError: () => RoleNotFoundError,
+  RollupScheduler: () => RollupScheduler,
+  RollupService: () => RollupService,
   SYSTEM_RESOURCES: () => SYSTEM_RESOURCES,
   SYSTEM_RESOURCE_LABELS: () => SYSTEM_RESOURCE_LABELS,
   SchemaError: () => SchemaError,
@@ -167,6 +176,7 @@ __export(index_exports, {
   TableTabConfig: () => TableTabConfig,
   UserProfileNotFoundError: () => UserProfileNotFoundError,
   UserProfileService: () => UserProfileService,
+  UserService: () => UserService,
   ValidationError: () => ValidationError,
   ViewBuilder: () => ViewBuilder,
   ViewService: () => ViewService,
@@ -181,6 +191,7 @@ __export(index_exports, {
   createDateValidator: () => createDateValidator,
   createDraftValidator: () => createDraftValidator,
   createFileValidator: () => createFileValidator,
+  createFormulaValidator: () => createFormulaValidator,
   createLocationValidator: () => createLocationValidator,
   createMockAdapter: () => createMockAdapter,
   createMultiRelationValidator: () => createMultiRelationValidator,
@@ -190,6 +201,8 @@ __export(index_exports, {
   createPhoneValidator: () => createPhoneValidator,
   createRatingValidator: () => createRatingValidator,
   createRelationValidator: () => createRelationValidator,
+  createRollupHooks: () => createRollupHooks,
+  createRollupValidator: () => createRollupValidator,
   createSelectValidator: () => createSelectValidator,
   createSingleRelationValidator: () => createSingleRelationValidator,
   createStatusValidator: () => createStatusValidator,
@@ -201,18 +214,34 @@ __export(index_exports, {
   date: () => date,
   dateConfigSchema: () => dateConfigSchema,
   enrichValuesWithSelectLabels: () => enrichValuesWithSelectLabels,
+  evaluateFormula: () => evaluateFormula,
+  evaluateFormulaAttribute: () => evaluateFormulaAttribute,
+  evaluateFormulaAttributeWithRelations: () => evaluateFormulaAttributeWithRelations,
+  evaluateFormulaWithRelations: () => evaluateFormulaWithRelations,
+  evaluateFormulaWithResult: () => evaluateFormulaWithResult,
   extractAttributeNames: () => extractAttributeNames,
+  extractFormulaVariables: () => extractFormulaVariables,
+  extractRelationNames: () => extractRelationNames,
+  extractRelationReferences: () => extractRelationReferences,
   file: () => file,
   fileConfigSchema: () => fileConfigSchema,
+  flattenRelationsForEval: () => flattenRelationsForEval,
   flow: () => flow,
   formatAttributeValue: () => formatAttributeValue,
+  formatFormulaResult: () => formatFormulaResult,
+  formula: () => formula,
+  formulaConfigSchema: () => formulaConfigSchema,
   generateId: () => generateId,
   generatePrefixedId: () => generatePrefixedId,
   getAttributeConfigSchema: () => getAttributeConfigSchema,
   getMissingRequiredAttributes: () => getMissingRequiredAttributes,
+  getPathDepth: () => getPathDepth,
+  getRelationPath: () => getRelationPath,
   getSyncPreview: () => getSyncPreview,
+  getTargetAttributeName: () => getTargetAttributeName,
   getViewSyncPreview: () => getViewSyncPreview,
   group: () => group,
+  hasRelationReferences: () => hasRelationReferences,
   isActivityTab: () => isActivityTab,
   isAdvancedFilterState: () => isAdvancedFilterState,
   isCustomTab: () => isCustomTab,
@@ -238,14 +267,21 @@ __export(index_exports, {
   numberConfigSchema: () => numberConfigSchema,
   object: () => object,
   parseAttributeConfig: () => parseAttributeConfig,
+  parsePath: () => parsePath,
+  pathHasManyCardinality: () => pathHasManyCardinality,
   phone: () => phone,
   phoneConfigSchema: () => phoneConfigSchema,
   rating: () => rating,
   ratingConfigSchema: () => ratingConfigSchema,
+  registerAllRollupHooks: () => registerAllRollupHooks,
   registry: () => registry,
   relation: () => relation,
   relationConfigSchema: () => relationConfigSchema,
   renderLabelExpression: () => renderLabelExpression,
+  resolveMultiplePaths: () => resolveMultiplePaths,
+  resolveSingleValue: () => resolveSingleValue,
+  rollup: () => rollup,
+  rollupConfigSchema: () => rollupConfigSchema,
   safeParseAttributeConfig: () => safeParseAttributeConfig,
   select: () => select,
   selectConfigSchema: () => selectConfigSchema,
@@ -262,14 +298,17 @@ __export(index_exports, {
   timestampConfigSchema: () => timestampConfigSchema,
   toAdvancedFilterState: () => toAdvancedFilterState,
   toSimpleFilterState: () => toSimpleFilterState,
+  traversePath: () => traversePath,
   user: () => user,
   userConfigSchema: () => userConfigSchema,
   validateAttribute: () => validateAttribute,
   validateAttributeConfig: () => validateAttributeConfig,
   validateDraft: () => validateDraft,
   validateDraftOrThrow: () => validateDraftOrThrow,
+  validateFormulaExpression: () => validateFormulaExpression,
   validateObject: () => validateObject,
   validateObjectOrThrow: () => validateObjectOrThrow,
+  validatePath: () => validatePath,
   verifyNativeObjectsSync: () => verifyNativeObjectsSync,
   verifyNativeViewsSync: () => verifyNativeViewsSync,
   view: () => view,
@@ -392,7 +431,24 @@ var OPERATORS_BY_TYPE = {
   file: ["is_empty", "is_not_empty"],
   user: ["contains", "not_contains", "is_empty", "is_not_empty"],
   relation: ["any_of", "none_of", "contains", "not_contains", "is_empty", "is_not_empty"],
-  rating: ["eq", "neq", "lt", "gt", "lte", "gte", "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"
+  ],
+  // Rollup: typically numeric aggregations
+  rollup: ["eq", "neq", "lt", "gt", "lte", "gte", "is_empty", "is_not_empty"]
 };
 var NO_VALUE_OPERATORS = [
   "is_empty",
@@ -469,6 +525,13 @@ function formatCheckbox(value) {
 function formatNumber(value, attribute) {
   if (typeof value !== "number") return String(value);
   const decimals = attribute.decimals;
+  if (attribute.unit === "percentage") {
+    return value.toLocaleString(void 0, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: decimals
+    });
+  }
   return value.toLocaleString(void 0, {
     minimumFractionDigits: decimals,
     maximumFractionDigits: decimals
@@ -640,6 +703,7 @@ var SchemaErrorCode = {
   // Protected Resources
   PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT",
   PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE",
+  PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW",
   PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE",
   // Permissions
   FORBIDDEN: "SCHEMA_FORBIDDEN",
@@ -728,7 +792,7 @@ var ValidationError = class _ValidationError extends SchemaError {
 };
 var ProtectedResourceError = class extends SchemaError {
   constructor(resourceType, resourceName, operation) {
-    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : SchemaErrorCode.PROTECTED_ATTRIBUTE;
+    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
     super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
       resourceType,
       resourceName,
@@ -943,7 +1007,9 @@ var BaseAttributeBuilder = class {
     return this;
   }
   defaultValue(value) {
-    this.attr.defaultValue = value;
+    if ("defaultValue" in this.attr || !["formula", "rollup"].includes(this.attr.type)) {
+      this.attr.defaultValue = value;
+    }
     return this;
   }
   metadata(value) {
@@ -1324,6 +1390,13 @@ var FileAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.verification = config;
     return this;
   }
+  /**
+   * Allow multiple files to be uploaded
+   */
+  multiple() {
+    this.attr.multiple = true;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this;
@@ -1344,6 +1417,13 @@ var UserAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.allowedRoles = roles;
     return this;
   }
+  /**
+   * Allow multiple users to be selected
+   */
+  multiple() {
+    this.attr.multiple = true;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this;
@@ -1471,6 +1551,105 @@ var RatingAttributeBuilder = class extends BaseAttributeBuilder {
 function rating(config) {
   return new RatingAttributeBuilder(config.name, config.label);
 }
+var FormulaAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("formula", name, label);
+    this.attr.required = false;
+  }
+  /**
+   * Set the formula expression
+   * @param expr - Expression to evaluate (e.g., "price * quantity")
+   */
+  expression(expr) {
+    this.attr.expression = expr;
+    return this;
+  }
+  /**
+   * Set the expected return type for formatting
+   * @param type - Return type: "text", "number", "boolean", or "date"
+   */
+  returns(type) {
+    this.attr.returnType = type;
+    return this;
+  }
+  /**
+   * Set decimal places for number results
+   */
+  decimals(value) {
+    this.attr.decimals = value;
+    return this;
+  }
+  // Override to prevent making formulas required
+  // biome-ignore lint/suspicious/noExplicitAny: intentional override
+  required() {
+    console.warn("Formula attributes cannot be required (they are read-only)");
+    return this;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: intentional override
+  optional() {
+    return this;
+  }
+};
+function formula(config) {
+  return new FormulaAttributeBuilder(config.name, config.label);
+}
+var RollupAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("rollup", name, label);
+    this.attr.required = false;
+  }
+  /**
+   * Set the relation attribute to aggregate from
+   * @param relationName - Name of the relation attribute on this object
+   */
+  from(relationName) {
+    this.attr.relationAttribute = relationName;
+    return this;
+  }
+  /**
+   * Set the target attribute to aggregate
+   * @param attrName - Name of the attribute on the related object
+   */
+  aggregate(attrName) {
+    this.attr.targetAttribute = attrName;
+    return this;
+  }
+  /**
+   * Set the aggregation function
+   */
+  using(fn) {
+    this.attr.function = fn;
+    return this;
+  }
+  /**
+   * Set decimal places for numeric results
+   */
+  decimals(value) {
+    this.attr.decimals = value;
+    return this;
+  }
+  /**
+   * Set multi-level path for traversing nested relations (Phase 4+)
+   * @param path - Dot notation path (e.g., "orders.items")
+   */
+  path(relationPath) {
+    this.attr.relationPath = relationPath;
+    return this;
+  }
+  // Override to prevent making rollups required
+  // biome-ignore lint/suspicious/noExplicitAny: intentional override
+  required() {
+    console.warn("Rollup attributes cannot be required (they are read-only)");
+    return this;
+  }
+  // biome-ignore lint/suspicious/noExplicitAny: intentional override
+  optional() {
+    return this;
+  }
+};
+function rollup(config) {
+  return new RollupAttributeBuilder(config.name, config.label);
+}
 
 // src/builders/flow-builder.ts
 var import_zod = require("zod");
@@ -2750,10 +2929,12 @@ var fileConfigSchema = baseConfigSchema.extend({
   maxFiles: import_zod4.z.number().int().min(1).optional(),
   maxSize: import_zod4.z.number().int().min(1).optional(),
   allowedTypes: import_zod4.z.array(import_zod4.z.string()).optional(),
-  verification: fileVerificationConfigSchema.optional()
+  verification: fileVerificationConfigSchema.optional(),
+  multiple: import_zod4.z.boolean().optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional()
+  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional(),
+  multiple: import_zod4.z.boolean().optional()
 });
 var relationConfigSchema = baseConfigSchema.extend({
   targets: import_zod4.z.array(relationTargetSchema).min(1),
@@ -2765,6 +2946,30 @@ var ratingConfigSchema = baseConfigSchema.extend({
   max: import_zod4.z.number().int().min(1).optional(),
   iconType: import_zod4.z.enum(["star", "heart", "thumbs", "number"]).optional()
 });
+var formulaConfigSchema = baseConfigSchema.extend({
+  expression: import_zod4.z.string().min(1),
+  returnType: import_zod4.z.enum(["text", "number", "boolean", "date"]),
+  decimals: import_zod4.z.number().int().min(0).max(10).optional(),
+  allowRelations: import_zod4.z.boolean().optional()
+});
+var rollupConfigSchema = baseConfigSchema.extend({
+  relationAttribute: import_zod4.z.string().min(1).optional(),
+  relationPath: import_zod4.z.string().optional(),
+  targetAttribute: import_zod4.z.string().min(1),
+  function: import_zod4.z.enum([
+    "sum",
+    "count",
+    "avg",
+    "min",
+    "max",
+    "countValues",
+    "countEmpty",
+    "percentEmpty",
+    "percentFilled"
+  ]),
+  decimals: import_zod4.z.number().int().min(0).max(10).optional(),
+  materialize: import_zod4.z.boolean().optional()
+});
 var attributeConfigSchemas = {
   text: textConfigSchema,
   textarea: textareaConfigSchema,
@@ -2781,7 +2986,9 @@ var attributeConfigSchemas = {
   file: fileConfigSchema,
   user: userConfigSchema,
   relation: relationConfigSchema,
-  rating: ratingConfigSchema
+  rating: ratingConfigSchema,
+  formula: formulaConfigSchema,
+  rollup: rollupConfigSchema
 };
 function getAttributeConfigSchema(type) {
   return attributeConfigSchemas[type];
@@ -2891,20 +3098,39 @@ function createLocationValidator(_attr) {
 function createTimestampValidator(_attr) {
   return import_zod4.z.number().int().positive();
 }
-function createFileValidator(_attr) {
-  return import_zod4.z.string().uuid();
+function createFileValidator(attr) {
+  const uuidSchema = import_zod4.z.uuid({
+    message: `${attr.label} must be a valid file ID`
+  });
+  if (attr.multiple) {
+    let arraySchema = import_zod4.z.array(uuidSchema);
+    if (attr.maxFiles) {
+      arraySchema = arraySchema.max(
+        attr.maxFiles,
+        `${attr.label} cannot have more than ${attr.maxFiles} file${attr.maxFiles > 1 ? "s" : ""}`
+      );
+    }
+    return arraySchema;
+  }
+  return uuidSchema;
 }
-function createUserValidator(_attr) {
-  return import_zod4.z.string().uuid();
+function createUserValidator(attr) {
+  const uuidSchema = import_zod4.z.uuid({
+    message: `${attr.label} must be a valid user ID`
+  });
+  if (attr.multiple) {
+    return import_zod4.z.array(uuidSchema);
+  }
+  return uuidSchema;
 }
 function createSingleRelationValidator(attr) {
-  const uuidSchema = import_zod4.z.string().uuid({
+  const uuidSchema = import_zod4.z.uuid({
     message: `${attr.label} must be a valid record ID`
   });
   return import_zod4.z.union([uuidSchema, import_zod4.z.null()]);
 }
 function createMultiRelationValidator(attr) {
-  const uuidSchema = import_zod4.z.string().uuid({
+  const uuidSchema = import_zod4.z.uuid({
     message: `Each ${attr.label} item must be a valid record ID`
   });
   let arraySchema = import_zod4.z.array(uuidSchema);
@@ -2935,6 +3161,12 @@ function createRatingValidator(attr) {
   }
   return schema;
 }
+function createFormulaValidator(_attr) {
+  return import_zod4.z.unknown();
+}
+function createRollupValidator(_attr) {
+  return import_zod4.z.unknown();
+}
 function createAttributeValidator(attr) {
   switch (attr.type) {
     case "text":
@@ -2967,6 +3199,10 @@ function createAttributeValidator(attr) {
       return createRelationValidator(attr);
     case "rating":
       return createRatingValidator(attr);
+    case "formula":
+      return createFormulaValidator(attr);
+    case "rollup":
+      return createRollupValidator(attr);
     default:
       return import_zod4.z.unknown();
   }
@@ -3092,139 +3328,771 @@ function computeRecordStatus(objectDef, data) {
   return isRecordComplete(objectDef, data) ? "complete" : "draft";
 }
 
-// src/runtime/hooks/hook.registry.ts
-var NoopHookRegistry = class {
-  async execute() {
+// src/runtime/formula/evaluator.ts
+var import_expr_eval = require("expr-eval");
+function createFormulaParser() {
+  const parser = new import_expr_eval.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 ?? "").replace(new RegExp(search, "g"), 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;
+    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;
+}
+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;
   }
-};
-
-// src/runtime/template.ts
-var pipes = {
-  /** Convert to uppercase */
-  UPPER: (v) => String(v).toUpperCase(),
-  /** Convert to lowercase */
-  LOWER: (v) => String(v).toLowerCase(),
-  /** Capitalize first letter of each word */
-  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
-  /** Trim whitespace from both ends */
-  trim: (v) => String(v).trim()
-};
-function getValue(obj, path) {
-  return path.split(".").reduce((acc, key) => {
-    if (acc == null || typeof acc !== "object") return void 0;
-    return acc[key];
-  }, obj);
+  return null;
 }
-var DEFAULT_LABEL_FALLBACK = "(Untitled)";
-function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
-  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
-    const parts = expr.split("|").map((s) => s.trim());
-    const path = parts[0];
-    let value = getValue(values, path);
-    if (value == null || value === "") return "";
-    for (let i = 1; i < parts.length; i++) {
-      const pipeName = parts[i].trim();
-      const fn = pipes[pipeName];
-      if (fn) {
-        value = fn(String(value));
-      }
-    }
-    return String(value);
-  }).trim();
-  return result || fallback;
+var formulaParser = createFormulaParser();
+function evaluateFormula(expression, values) {
+  try {
+    const parsed = formulaParser.parse(expression);
+    return parsed.evaluate(values);
+  } catch {
+    return null;
+  }
 }
-function isLabelExpression(value) {
-  return /\{\{\s*\S+.*\}\}/.test(value);
+function evaluateFormulaWithResult(expression, values) {
+  try {
+    const parsed = formulaParser.parse(expression);
+    const value = parsed.evaluate(values);
+    return { value };
+  } catch (error) {
+    return {
+      value: null,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
 }
-function extractAttributeNames(template) {
-  const names = [];
-  const regex = /\{\{\s*([^|}]+)/g;
-  let match;
-  while ((match = regex.exec(template)) !== null) {
-    const path = match[1].trim();
-    const rootName = path.split(".")[0];
-    if (rootName && !names.includes(rootName)) {
-      names.push(rootName);
-    }
+function formatFormulaResult(value, returnType, decimals) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  switch (returnType) {
+    case "number":
+      return formatNumberResult(value, decimals);
+    case "boolean":
+      return Boolean(value);
+    case "date":
+      return formatDateResult(value);
+    case "text":
+      return String(value);
   }
-  return names;
 }
-function hasOptions(attr) {
-  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+function formatNumberResult(value, decimals) {
+  const num = typeof value === "number" ? value : Number(value);
+  if (Number.isNaN(num)) return null;
+  return decimals !== void 0 ? Number(num.toFixed(decimals)) : num;
 }
-function enrichValuesWithSelectLabels(values, attributes) {
-  const enriched = { ...values };
-  for (const attr of attributes) {
-    const value = values[attr.name];
-    if (value == null) continue;
-    const isSelectLike = attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
-    if (!(isSelectLike && hasOptions(attr))) continue;
-    if (attr.type === "multiselect" && Array.isArray(value) && value.length === 0) continue;
-    const formatted = formatAttributeValue(value, attr);
-    if (formatted && formatted !== EMPTY_VALUE_PLACEHOLDER) {
-      enriched[attr.name] = formatted;
+function formatDateResult(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (typeof value === "string") return value;
+  return null;
+}
+function evaluateFormulaAttribute(attr, values) {
+  const raw = evaluateFormula(attr.expression, values);
+  return formatFormulaResult(raw, attr.returnType, attr.decimals);
+}
+function validateFormulaExpression(expression) {
+  try {
+    formulaParser.parse(expression);
+    return { valid: true };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Invalid expression"
+    };
+  }
+}
+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 flat = {};
+  for (const [relationName, values] of Object.entries(resolvedRelations)) {
+    for (const [key, value] of Object.entries(values)) {
+      flat[`${relationName}.${key}`] = value;
     }
   }
-  return enriched;
+  return flat;
+}
+async function evaluateFormulaWithRelations(expression, record, schema, resolver) {
+  const relationNames = extractRelationNames(expression);
+  if (relationNames.length === 0) {
+    return evaluateFormula(expression, record.values);
+  }
+  const resolvedRelations = await resolver.resolveRelationValues(record, schema, relationNames);
+  const flattenedRelations = flattenRelationsForEval(resolvedRelations);
+  const allValues = {
+    ...record.values,
+    ...flattenedRelations
+  };
+  return evaluateFormula(expression, allValues);
+}
+async function evaluateFormulaAttributeWithRelations(attr, record, schema, resolver) {
+  const raw = await evaluateFormulaWithRelations(attr.expression, record, schema, resolver);
+  return formatFormulaResult(raw, attr.returnType, attr.decimals);
 }
 
-// src/runtime/mock-adapter.ts
-function createMockObjectsRepository(stores) {
-  return {
-    findById(id) {
-      return Promise.resolve(stores.objects.get(id) ?? null);
-    },
-    findByName(tenantId, name) {
-      for (const obj of stores.objects.values()) {
-        if (obj.tenantId === tenantId && obj.name === name) {
-          return Promise.resolve(obj);
-        }
+// src/runtime/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");
       }
-      return Promise.resolve(null);
-    },
-    findSystemByName(name) {
-      for (const obj of stores.objects.values()) {
-        if (obj.system && obj.name === name) {
-          return Promise.resolve(obj);
+      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`
+          );
         }
+        currentSchema = nextSchema;
       }
-      return Promise.resolve(null);
-    },
-    create(data) {
-      const obj = {
-        id: generateId(),
-        tenantId: data.tenantId,
-        name: data.name,
-        label: data.label,
-        pluralLabel: data.pluralLabel,
-        description: data.description,
-        icon: data.icon,
-        labelExpression: data.labelExpression,
-        system: data.system ?? false,
-        metadata: data.metadata,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.objects.set(obj.id, obj);
-      return Promise.resolve(obj);
-    },
-    update(id, data) {
-      const existing = stores.objects.get(id);
-      if (!existing) {
-        return Promise.reject(new Error(`Object ${id} not found`));
+    } else {
+      if (!isLastSegment) {
+        throw new InvalidPathError(
+          path,
+          segmentName,
+          `"${segmentName}" is not a relation but has segments after it`
+        );
       }
-      const updated = {
-        ...existing,
-        ...data,
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.objects.set(id, updated);
-      return Promise.resolve(updated);
-    },
-    delete(id) {
-      stores.objects.delete(id);
-      return Promise.resolve();
-    },
+      result.push({
+        name: segmentName,
+        type: "attribute"
+      });
+    }
+  }
+  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 getTargetAttributeName(path) {
+  const parts = path.split(".");
+  return parts[parts.length - 1];
+}
+function getRelationPath(path) {
+  const parts = path.split(".");
+  if (parts.length <= 1) return null;
+  return parts.slice(0, -1).join(".");
+}
+
+// src/runtime/formula/path-traversal.ts
+async function traversePath(record, path, startSchemaName, adapter, getSchema, options) {
+  const maxDepth = options?.maxDepth ?? 5;
+  const startSchema = await getSchema(startSchemaName);
+  if (!startSchema) {
+    return { values: [], recordCounts: [0] };
+  }
+  const segments = await parsePath(path, startSchema, getSchema, maxDepth);
+  if (segments.length > maxDepth) {
+    throw new MaxDepthExceededError(path, maxDepth);
+  }
+  return await executeTraversal([record], segments, adapter, 0);
+}
+async function executeTraversal(records, segments, adapter, depth) {
+  const recordCounts = [records.length];
+  if (depth >= segments.length || records.length === 0) {
+    return { values: [], recordCounts };
+  }
+  const segment = segments[depth];
+  const isLastSegment = depth === segments.length - 1;
+  if (segment.type === "attribute") {
+    const values = records.map((r) => r.values[segment.name]).filter((v) => v !== void 0);
+    return { values, recordCounts };
+  }
+  const relatedIds = collectRelatedIds(records, segment.name);
+  if (relatedIds.length === 0) {
+    return { values: [], recordCounts };
+  }
+  const relatedRecords = await adapter.objectRecords.findByIds(relatedIds);
+  recordCounts.push(relatedRecords.length);
+  if (isLastSegment) {
+    return { values: relatedIds, recordCounts };
+  }
+  const nestedResult = await executeTraversal(relatedRecords, segments, adapter, depth + 1);
+  return {
+    values: nestedResult.values,
+    recordCounts: [...recordCounts, ...nestedResult.recordCounts.slice(1)]
+  };
+}
+function collectRelatedIds(records, relationName) {
+  const ids = [];
+  for (const record of records) {
+    const value = record.values[relationName];
+    if (typeof value === "string" && value.length > 0) {
+      ids.push(value);
+    } else if (Array.isArray(value)) {
+      for (const id of value) {
+        if (typeof id === "string" && id.length > 0) {
+          ids.push(id);
+        }
+      }
+    }
+  }
+  return [...new Set(ids)];
+}
+async function resolveSingleValue(record, path, startSchemaName, adapter, getSchema) {
+  const result = await traversePath(record, path, startSchemaName, adapter, getSchema);
+  return result.values[0] ?? null;
+}
+async function resolveMultiplePaths(record, paths, startSchemaName, adapter, getSchema) {
+  const results = /* @__PURE__ */ new Map();
+  await Promise.all(
+    paths.map(async (path) => {
+      const result = await traversePath(record, path, startSchemaName, adapter, getSchema);
+      results.set(path, result.values);
+    })
+  );
+  return results;
+}
+
+// src/runtime/hooks/hook.registry.ts
+var NoopHookRegistry = class {
+  async execute() {
+  }
+};
+
+// src/runtime/services/rollup.service.ts
+var RollupService = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Calculate a rollup value for a record
+   *
+   * @param recordId - ID of the parent record
+   * @param rollupAttr - Rollup attribute definition
+   * @param schema - Schema of the parent object
+   * @returns Computed rollup value
+   *
+   * @example
+   * ```typescript
+   * // Sum all order amounts for a company
+   * const totalOrders = await rollupService.calculate(
+   *   "company-123",
+   *   {
+   *     type: "rollup",
+   *     name: "totalOrders",
+   *     relationAttribute: "orders",
+   *     targetAttribute: "amount",
+   *     function: "sum",
+   *     ...
+   *   },
+   *   companySchema
+   * );
+   * ```
+   */
+  async calculate(recordId, rollupAttr, schema, tenantId) {
+    const relationAttr = schema.attributes.find(
+      (a) => a.type === "relation" && a.name === rollupAttr.relationAttribute
+    );
+    if (!relationAttr) {
+      return { value: null, recordCount: 0 };
+    }
+    const targetObjectName = relationAttr.targets[0]?.object;
+    if (!targetObjectName) {
+      return { value: null, recordCount: 0 };
+    }
+    const targetObject = await this.adapter.objects.findByName(tenantId, targetObjectName);
+    if (!targetObject) {
+      return { value: null, recordCount: 0 };
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByRelation(
+      tenantId,
+      targetObject.id,
+      rollupAttr.relationAttribute,
+      recordId
+    );
+    if (relatedRecords.length === 0) {
+      return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
+    }
+    const values = relatedRecords.map((r) => r.values[rollupAttr.targetAttribute]).filter((v) => v !== void 0);
+    const aggregated = this.aggregate(values, rollupAttr.function);
+    const result = typeof aggregated === "number" && rollupAttr.decimals !== void 0 ? Number(aggregated.toFixed(rollupAttr.decimals)) : aggregated;
+    return { value: result, recordCount: relatedRecords.length };
+  }
+  /**
+   * Calculate rollup values for multiple records (batched)
+   *
+   * More efficient than calling calculate() for each record individually.
+   */
+  async calculateForMany(recordIds, rollupAttr, schema, tenantId) {
+    const results = /* @__PURE__ */ new Map();
+    for (const id of recordIds) {
+      results.set(id, { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 });
+    }
+    await Promise.all(
+      recordIds.map(async (id) => {
+        const result = await this.calculate(id, rollupAttr, schema, tenantId);
+        results.set(id, result);
+      })
+    );
+    return results;
+  }
+  /**
+   * Apply aggregation function to a set of values
+   */
+  aggregate(values, fn) {
+    switch (fn) {
+      case "sum":
+        return this.sumNumbers(values);
+      case "avg":
+        return this.averageNumbers(values);
+      case "min":
+        return this.minNumbers(values);
+      case "max":
+        return this.maxNumbers(values);
+      case "count":
+        return values.length;
+      case "countValues":
+        return values.filter((v) => v != null && v !== "").length;
+      case "countEmpty":
+        return values.filter((v) => v == null || v === "").length;
+      case "percentFilled": {
+        if (values.length === 0) return 0;
+        const filled = values.filter((v) => v != null && v !== "").length;
+        return filled / values.length * 100;
+      }
+      case "percentEmpty": {
+        if (values.length === 0) return 0;
+        const empty = values.filter((v) => v == null || v === "").length;
+        return empty / values.length * 100;
+      }
+    }
+  }
+  /**
+   * Get the default empty value for a rollup function
+   */
+  getEmptyValue(fn) {
+    switch (fn) {
+      case "sum":
+      case "count":
+      case "countValues":
+      case "countEmpty":
+      case "percentEmpty":
+      case "percentFilled":
+        return 0;
+      case "avg":
+      case "min":
+      case "max":
+        return null;
+    }
+  }
+  /**
+   * Sum numeric values
+   */
+  sumNumbers(values) {
+    return values.filter((v) => typeof v === "number" && !Number.isNaN(v)).reduce((sum, n) => sum + n, 0);
+  }
+  /**
+   * Average numeric values
+   */
+  averageNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return nums.reduce((sum, n) => sum + n, 0) / nums.length;
+  }
+  /**
+   * Minimum numeric value
+   */
+  minNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return Math.min(...nums);
+  }
+  /**
+   * Maximum numeric value
+   */
+  maxNumbers(values) {
+    const nums = values.filter((v) => typeof v === "number" && !Number.isNaN(v));
+    if (nums.length === 0) return null;
+    return Math.max(...nums);
+  }
+  /**
+   * Recalculate all rollup attributes for a record and update it
+   *
+   * Called after related records change to keep rollups up-to-date.
+   */
+  async recalculateAndUpdate(record, schema, tenantId) {
+    const rollupAttrs = schema.attributes.filter((a) => a.type === "rollup");
+    if (rollupAttrs.length === 0) {
+      return record;
+    }
+    const updates = {};
+    for (const attr of rollupAttrs) {
+      const result = await this.calculate(record.id, attr, schema, tenantId);
+      updates[attr.name] = result.value;
+    }
+    return await this.adapter.objectRecords.update(record.id, updates);
+  }
+  /**
+   * Find parent records that need rollup recalculation when a child record changes
+   *
+   * Used by hooks to determine which parent records to recalculate after
+   * a child record is created, updated, or deleted.
+   *
+   * @param changedRecord - The record that was modified
+   * @param changedSchema - Schema of the changed record's object
+   * @returns Array of parent record IDs that need recalculation
+   */
+  async findAffectedParentRecords(changedRecord, changedSchema) {
+    const affectedIds = [];
+    const relationAttrs = changedSchema.attributes.filter(
+      (a) => a.type === "relation"
+    );
+    for (const attr of relationAttrs) {
+      const relatedId = changedRecord.values[attr.name];
+      if (typeof relatedId === "string" && relatedId.length > 0) {
+        affectedIds.push(relatedId);
+      } else if (Array.isArray(relatedId)) {
+        affectedIds.push(...relatedId.filter((id) => typeof id === "string"));
+      }
+    }
+    return [...new Set(affectedIds)];
+  }
+};
+
+// src/runtime/hooks/rollup.hooks.ts
+function createRollupHooks(objectName, config) {
+  const rollupService = new RollupService(config.adapter);
+  async function recalculateParentRollups(ctx) {
+    const schema = await config.getSchemaById(ctx.objectId);
+    if (!schema) return;
+    const affectedParentIds = await rollupService.findAffectedParentRecords(ctx.record, schema);
+    if (affectedParentIds.length === 0) return;
+    const parentRecords = await config.adapter.objectRecords.findByIds(affectedParentIds);
+    for (const parentRecord of parentRecords) {
+      const parentSchema = await config.getSchemaById(parentRecord.objectId);
+      if (!parentSchema) continue;
+      const hasRollups = parentSchema.attributes.some(
+        (a) => a.type === "rollup"
+      );
+      if (hasRollups) {
+        await rollupService.recalculateAndUpdate(parentRecord, parentSchema, config.tenantId);
+      }
+    }
+  }
+  return [
+    {
+      type: "afterCreate",
+      objectName,
+      handler: recalculateParentRollups,
+      priority: 100
+      // Run after other hooks
+    },
+    {
+      type: "afterUpdate",
+      objectName,
+      handler: recalculateParentRollups,
+      priority: 100
+    },
+    {
+      type: "afterDelete",
+      objectName,
+      handler: recalculateParentRollups,
+      priority: 100
+    }
+  ];
+}
+function registerAllRollupHooks(hookRegistry, schemas, config) {
+  for (const schema of schemas) {
+    const hasRelations = schema.attributes.some((a) => a.type === "relation");
+    if (hasRelations && hookRegistry.register) {
+      const hooks = createRollupHooks(schema.name, config);
+      for (const hook of hooks) {
+        hookRegistry.register(hook);
+      }
+    }
+  }
+}
+
+// src/runtime/template.ts
+var pipes = {
+  /** Convert to uppercase */
+  UPPER: (v) => String(v).toUpperCase(),
+  /** Convert to lowercase */
+  LOWER: (v) => String(v).toLowerCase(),
+  /** Capitalize first letter of each word */
+  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
+  /** Trim whitespace from both ends */
+  trim: (v) => String(v).trim()
+};
+function getValue(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc == null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+var DEFAULT_LABEL_FALLBACK = "(Untitled)";
+function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
+  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
+    const parts = expr.split("|").map((s) => s.trim());
+    const path = parts[0];
+    let value = getValue(values, path);
+    if (value == null || value === "") return "";
+    for (let i = 1; i < parts.length; i++) {
+      const pipeName = parts[i].trim();
+      const fn = pipes[pipeName];
+      if (fn) {
+        value = fn(String(value));
+      }
+    }
+    return String(value);
+  }).trim();
+  return result || fallback;
+}
+function isLabelExpression(value) {
+  return /\{\{\s*\S+.*\}\}/.test(value);
+}
+function extractAttributeNames(template) {
+  const names = [];
+  const regex = /\{\{\s*([^|}]+)/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const path = match[1].trim();
+    const rootName = path.split(".")[0];
+    if (rootName && !names.includes(rootName)) {
+      names.push(rootName);
+    }
+  }
+  return names;
+}
+function hasOptions(attr) {
+  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+}
+function enrichValuesWithSelectLabels(values, attributes) {
+  const enriched = { ...values };
+  for (const attr of attributes) {
+    const value = values[attr.name];
+    if (value == null) continue;
+    const isSelectLike = attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
+    if (!(isSelectLike && hasOptions(attr))) continue;
+    if (attr.type === "multiselect" && Array.isArray(value) && value.length === 0) continue;
+    const formatted = formatAttributeValue(value, attr);
+    if (formatted && formatted !== EMPTY_VALUE_PLACEHOLDER) {
+      enriched[attr.name] = formatted;
+    }
+  }
+  return enriched;
+}
+
+// src/runtime/mock-adapter.ts
+function createMockObjectsRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.objects.get(id) ?? null);
+    },
+    findByName(tenantId, name) {
+      for (const obj of stores.objects.values()) {
+        if (obj.tenantId === tenantId && obj.name === name) {
+          return Promise.resolve(obj);
+        }
+      }
+      return Promise.resolve(null);
+    },
+    findSystemByName(name) {
+      for (const obj of stores.objects.values()) {
+        if (obj.system && obj.name === name) {
+          return Promise.resolve(obj);
+        }
+      }
+      return Promise.resolve(null);
+    },
+    create(data) {
+      const obj = {
+        id: generateId(),
+        tenantId: data.tenantId,
+        name: data.name,
+        label: data.label,
+        pluralLabel: data.pluralLabel,
+        description: data.description,
+        icon: data.icon,
+        labelExpression: data.labelExpression,
+        system: data.system ?? false,
+        metadata: data.metadata,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objects.set(obj.id, obj);
+      return Promise.resolve(obj);
+    },
+    update(id, data) {
+      const existing = stores.objects.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`Object ${id} not found`));
+      }
+      const updated = {
+        ...existing,
+        ...data,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objects.set(id, updated);
+      return Promise.resolve(updated);
+    },
+    delete(id) {
+      stores.objects.delete(id);
+      return Promise.resolve();
+    },
     list(tenantId) {
       const results = Array.from(stores.objects.values()).filter(
         (obj) => obj.tenantId === tenantId
@@ -3755,6 +4623,26 @@ function createMockObjectRecordsRepository(stores) {
         }
       }
       return Promise.resolve(updated);
+    },
+    findByRelation(objectName, relationAttributeName, targetRecordId) {
+      const obj = Array.from(stores.objects.values()).find((o) => o.name === objectName);
+      if (!obj) return Promise.resolve([]);
+      const results = [];
+      for (const record of stores.objectRecords.values()) {
+        if (record.objectId !== obj.id) continue;
+        const value = record.values[relationAttributeName];
+        let matches = false;
+        if (typeof value === "string" && value === targetRecordId) {
+          matches = true;
+        } else if (Array.isArray(value) && value.includes(targetRecordId)) {
+          matches = true;
+        }
+        if (matches) {
+          const { tenantId: _, ...publicRecord } = record;
+          results.push(publicRecord);
+        }
+      }
+      return Promise.resolve(results);
     }
   };
 }
@@ -4174,6 +5062,24 @@ var AuditService = class {
     };
     await this.log(entry);
   }
+  /**
+   * Log a file action (upload, update, delete)
+   */
+  async logFileAction(params) {
+    const entry = {
+      tenantId: this.tenantId,
+      actorId: params.actorId,
+      actorEmail: params.actorEmail,
+      actorType: "user",
+      action: params.action,
+      resourceType: "file",
+      resourceId: params.fileId,
+      resourceLabel: params.fileName,
+      changes: params.changes ? this.redactSensitiveFields(params.changes) : void 0,
+      metadata: params.metadata
+    };
+    await this.log(entry);
+  }
   /**
    * Log a system action (no actor)
    */
@@ -4323,21 +5229,105 @@ var AuditService = class {
 
 // src/runtime/services/file.service.ts
 var FileService = class {
-  constructor(adapter, tenantId) {
+  constructor(adapter, tenantId, options) {
     this.adapter = adapter;
     this.tenantId = tenantId;
+    this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
+    this.userId = options?.userId;
+    this.userEmail = options?.userEmail;
   }
+  // ============================================================================
+  // UPLOAD (requires StorageAdapter)
+  // ============================================================================
   /**
-   * Create a new file record (after upload to storage)
+   * Upload a file to storage and create metadata record.
    *
-   * @param data - File metadata
+   * This method orchestrates:
+   * 1. Upload to storage (via StorageAdapter)
+   * 2. Create file metadata in database
+   * 3. Audit log the operation
+   *
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param input - File content and metadata
    * @returns Created file record
+   * @throws Error if StorageAdapter is not configured
    *
    * @example
    * ```typescript
-   * const service = new FileService(adapter, "tenant-123");
+   * const file = await service.uploadFile({
+   *   content: fileBuffer,
+   *   fileName: "document.pdf",
+   *   mimeType: "application/pdf",
+   *   size: 12345,
+   *   uploadedBy: "user-123",
+   *   visibility: "private",
+   *   folderPath: "/documents",
+   *   tags: ["contract", "2025"],
+   * });
+   * ```
+   */
+  async uploadFile(input) {
+    if (!this.adapter.storage) {
+      throw new Error(
+        "StorageAdapter is not configured. Provide adapter.storage to use uploadFile()."
+      );
+    }
+    const uploadResult = await this.adapter.storage.upload({
+      content: input.content,
+      fileName: input.fileName,
+      mimeType: input.mimeType,
+      size: input.size,
+      tenantId: this.tenantId,
+      folderPath: input.folderPath
+    });
+    const file2 = await this.adapter.files.create({
+      tenantId: this.tenantId,
+      name: input.fileName,
+      originalName: input.fileName,
+      mimeType: input.mimeType,
+      size: input.size,
+      storageProvider: uploadResult.storageProvider,
+      storagePath: uploadResult.storagePath,
+      storageBucket: uploadResult.storageBucket,
+      url: uploadResult.url,
+      uploadedBy: input.uploadedBy,
+      folderPath: input.folderPath,
+      tags: input.tags,
+      visibility: input.visibility ?? "private",
+      allowedUsers: input.allowedUsers
+    });
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.uploaded",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId: file2.id,
+        fileName: file2.name,
+        metadata: {
+          mimeType: file2.mimeType,
+          size: file2.size,
+          visibility: file2.visibility
+        }
+      });
+    }
+    return file2;
+  }
+  // ============================================================================
+  // CREATE (metadata only, for external storage)
+  // ============================================================================
+  /**
+   * Create a new file record (after upload to storage).
+   *
+   * Use this method when handling storage externally (e.g., with Multer + S3).
+   * For integrated upload, use `uploadFile()` instead.
    *
-   * // After uploading to S3
+   * @param data - File metadata
+   * @returns Created file record
+   *
+   * @example
+   * ```typescript
+   * // After uploading to S3 with Multer
    * const file = await service.createFile({
    *   tenantId: "tenant-123",
    *   name: "contract-2025.pdf",
@@ -4359,8 +5349,26 @@ var FileService = class {
         `Tenant mismatch: service initialized with "${this.tenantId}" but data has "${data.tenantId}"`
       );
     }
-    return await this.adapter.files.create(data);
+    const file2 = await this.adapter.files.create(data);
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.uploaded",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId: file2.id,
+        fileName: file2.name,
+        metadata: {
+          mimeType: file2.mimeType,
+          size: file2.size,
+          visibility: file2.visibility
+        }
+      });
+    }
+    return file2;
   }
+  // ============================================================================
+  // READ
+  // ============================================================================
   /**
    * Get file by ID
    */
@@ -4381,6 +5389,9 @@ var FileService = class {
     }
     return file2;
   }
+  // ============================================================================
+  // UPDATE
+  // ============================================================================
   /**
    * Update file metadata
    *
@@ -4389,18 +5400,44 @@ var FileService = class {
    * @returns Updated file
    */
   async updateFile(fileId, data) {
-    await this.getFileOrThrow(fileId);
-    return await this.adapter.files.update(fileId, data);
+    const existingFile = await this.getFileOrThrow(fileId);
+    const updatedFile = await this.adapter.files.update(fileId, data);
+    if (this.auditService && this.userId) {
+      const changes = [];
+      for (const key of Object.keys(data)) {
+        if (data[key] !== void 0 && data[key] !== existingFile[key]) {
+          changes.push({
+            field: key,
+            oldValue: existingFile[key],
+            newValue: data[key]
+          });
+        }
+      }
+      if (changes.length > 0) {
+        await this.auditService.logFileAction({
+          action: "file.updated",
+          actorId: this.userId,
+          actorEmail: this.userEmail,
+          fileId,
+          fileName: updatedFile.name,
+          changes
+        });
+      }
+    }
+    return updatedFile;
   }
+  // ============================================================================
+  // DELETE
+  // ============================================================================
   /**
-   * Delete file (soft delete)
+   * Delete file (soft delete by default)
    *
    * @param fileId - File UUID
    * @param options - Delete options
    */
   async deleteFile(fileId, options) {
+    const file2 = await this.getFileOrThrow(fileId);
     if (options?.checkOwnership && options.userId) {
-      const file2 = await this.getFileOrThrow(fileId);
       if (file2.uploadedBy !== options.userId) {
         throw new Error("You can only delete files you uploaded");
       }
@@ -4410,7 +5447,84 @@ var FileService = class {
     } else {
       await this.adapter.files.delete(fileId);
     }
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.deleted",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId,
+        fileName: file2.name
+      });
+    }
   }
+  /**
+   * Delete file from both storage and database.
+   *
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param fileId - File UUID
+   * @param options - Delete options
+   * @throws Error if StorageAdapter is not configured
+   */
+  async deleteFileWithStorage(fileId, options) {
+    if (!this.adapter.storage) {
+      throw new Error(
+        "StorageAdapter is not configured. Provide adapter.storage to use deleteFileWithStorage()."
+      );
+    }
+    const file2 = await this.getFileOrThrow(fileId);
+    await this.adapter.storage.delete(file2.storagePath);
+    if (options?.hard) {
+      await this.adapter.files.hardDelete(fileId);
+    } else {
+      await this.adapter.files.delete(fileId);
+    }
+    if (this.auditService && this.userId) {
+      await this.auditService.logFileAction({
+        action: "file.deleted",
+        actorId: this.userId,
+        actorEmail: this.userEmail,
+        fileId,
+        fileName: file2.name,
+        metadata: { deletedFromStorage: true }
+      });
+    }
+  }
+  /**
+   * Delete multiple files
+   *
+   * @param fileIds - Array of file UUIDs
+   * @param options - Delete options
+   */
+  async bulkDelete(fileIds, options) {
+    for (const fileId of fileIds) {
+      const file2 = await this.getFile(fileId);
+      if (!file2) {
+        continue;
+      }
+      if (options?.deleteFromStorage && this.adapter.storage) {
+        await this.adapter.storage.delete(file2.storagePath);
+      }
+      if (options?.hard) {
+        await this.adapter.files.hardDelete(fileId);
+      } else {
+        await this.adapter.files.delete(fileId);
+      }
+      if (this.auditService && this.userId) {
+        await this.auditService.logFileAction({
+          action: "file.deleted",
+          actorId: this.userId,
+          actorEmail: this.userEmail,
+          fileId,
+          fileName: file2.name,
+          metadata: { deletedFromStorage: options?.deleteFromStorage ?? false }
+        });
+      }
+    }
+  }
+  // ============================================================================
+  // LIST
+  // ============================================================================
   /**
    * List files for the tenant
    */
@@ -4418,16 +5532,84 @@ var FileService = class {
     return await this.adapter.files.list(this.tenantId, options);
   }
   /**
-   * List files by folder
+   * List files by folder
+   */
+  async listFilesByFolder(folderPath) {
+    return await this.adapter.files.findByFolder(this.tenantId, folderPath);
+  }
+  /**
+   * List files uploaded by a specific user
+   */
+  async listFilesByUploader(uploadedBy) {
+    return await this.adapter.files.findByUploader(uploadedBy);
+  }
+  // ============================================================================
+  // SIGNED URL
+  // ============================================================================
+  /**
+   * Get a signed URL for private file access.
+   *
+   * Checks access permissions before generating URL.
+   * Requires `adapter.storage` to be configured.
+   *
+   * @param fileId - File UUID
+   * @param userId - User requesting access
+   * @param options - Signed URL options
+   * @returns Signed URL
+   * @throws Error if user doesn't have access or StorageAdapter is not configured
+   *
+   * @example
+   * ```typescript
+   * const url = await service.getSignedUrl("file-123", "user-456", {
+   *   expiresIn: 3600, // 1 hour
+   * });
+   * ```
+   */
+  async getSignedUrl(fileId, userId, options) {
+    const file2 = await this.getFileOrThrow(fileId);
+    const hasAccess = await this.checkAccess(fileId, userId);
+    if (!hasAccess) {
+      throw new Error("Access denied to this file");
+    }
+    if (file2.visibility === "public") {
+      return file2.url;
+    }
+    if (!this.adapter.storage) {
+      return file2.url;
+    }
+    return await this.adapter.storage.getSignedUrl(file2.storagePath, options);
+  }
+  // ============================================================================
+  // ACCESS CONTROL
+  // ============================================================================
+  /**
+   * Check if user has access to a file
+   *
+   * @param fileId - File UUID
+   * @param userId - User ID to check
+   * @returns true if user can access the file
    */
-  async listFilesByFolder(folderPath) {
-    return await this.adapter.files.findByFolder(this.tenantId, folderPath);
+  async checkAccess(fileId, userId) {
+    const file2 = await this.getFile(fileId);
+    if (!file2) {
+      return false;
+    }
+    if (file2.visibility === "public") {
+      return true;
+    }
+    if (file2.uploadedBy === userId) {
+      return true;
+    }
+    if (file2.visibility === "restricted") {
+      return file2.allowedUsers?.includes(userId) ?? false;
+    }
+    return false;
   }
   /**
-   * List files uploaded by a specific user
+   * @deprecated Use checkAccess() instead
    */
-  async listFilesByUploader(uploadedBy) {
-    return await this.adapter.files.findByUploader(uploadedBy);
+  canAccess(fileId, userId) {
+    return this.checkAccess(fileId, userId);
   }
   /**
    * Change file visibility
@@ -4472,29 +5654,9 @@ var FileService = class {
       allowedUsers: newAllowed
     });
   }
-  /**
-   * Check if user has access to a file
-   *
-   * @param fileId - File UUID
-   * @param userId - User ID to check
-   * @returns true if user can access the file
-   */
-  async canAccess(fileId, userId) {
-    const file2 = await this.getFile(fileId);
-    if (!file2) {
-      return false;
-    }
-    if (file2.visibility === "public") {
-      return true;
-    }
-    if (file2.uploadedBy === userId) {
-      return true;
-    }
-    if (file2.visibility === "restricted") {
-      return file2.allowedUsers?.includes(userId) ?? false;
-    }
-    return false;
-  }
+  // ============================================================================
+  // ORGANIZATION
+  // ============================================================================
   /**
    * Move file to different folder
    */
@@ -6330,6 +7492,123 @@ var RelationService = class {
   }
 };
 
+// src/runtime/services/user.service.ts
+var UserService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Validate all user attributes in the data
+   *
+   * @param schema - Object schema containing attribute definitions
+   * @param data - Record data to validate
+   * @returns Validation result with errors if any
+   *
+   * @example
+   * ```typescript
+   * const result = await userService.validateUsers(schema, {
+   *   assignee: "user-123",
+   *   watchers: ["user-456", "user-789"]
+   * });
+   *
+   * if (!result.valid) {
+   *   console.log(result.errors);
+   *   // [{ attribute: "assignee", message: "User not found", invalidIds: ["user-123"] }]
+   * }
+   * ```
+   */
+  async validateUsers(schema, data) {
+    const errors = [];
+    const userAttrs = schema.attributes.filter(
+      (attr) => attr.type === "user"
+    );
+    for (const attr of userAttrs) {
+      const value = data[attr.name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const attrErrors = await this.validateUserAttribute(attr, value);
+      errors.push(...attrErrors);
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Validate a single user attribute value
+   */
+  async validateUserAttribute(attr, value) {
+    const errors = [];
+    const ids = this.extractIds(attr, value);
+    if (ids.length === 0) {
+      return errors;
+    }
+    const invalidIds = [];
+    const roleErrors = [];
+    for (const id of ids) {
+      const user2 = await this.adapter.userProfiles.findById(id);
+      if (!user2) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (user2.tenantId !== this.tenantId) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (attr.allowedRoles && attr.allowedRoles.length > 0) {
+        if (!attr.allowedRoles.includes(user2.role)) {
+          roleErrors.push(id);
+        }
+      }
+    }
+    if (invalidIds.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Invalid or non-existent users for ${attr.label}`,
+        invalidIds
+      });
+    }
+    if (roleErrors.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Users do not have required role for ${attr.label}. Allowed roles: ${attr.allowedRoles?.join(", ")}`,
+        invalidIds: roleErrors
+      });
+    }
+    return errors;
+  }
+  /**
+   * Extract IDs from user value based on multiple flag
+   */
+  extractIds(attr, value) {
+    if (attr.multiple) {
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.filter((v) => typeof v === "string" && v !== "");
+    }
+    if (typeof value === "string" && value !== "") {
+      return [value];
+    }
+    return [];
+  }
+  /**
+   * Validate users and throw if invalid
+   */
+  async validateUsersOrThrow(schema, data) {
+    const result = await this.validateUsers(schema, data);
+    if (!result.valid) {
+      const errors = result.errors.map((e) => ({
+        path: [e.attribute],
+        message: e.message
+      }));
+      throw new ValidationError("User validation failed", errors);
+    }
+  }
+};
+
 // src/runtime/services/record.service.ts
 var RecordService = class {
   constructor(adapter, tenantId, options) {
@@ -6337,6 +7616,7 @@ var RecordService = class {
     this.tenantId = tenantId;
     this.schemaService = new ObjectSchemaService(adapter, registry);
     this.relationService = new RelationService(adapter, registry);
+    this.userService = new UserService(adapter, tenantId);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
     this.permissionService = options?.permissionService;
     this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
@@ -6477,6 +7757,9 @@ var RecordService = class {
       if (!options?.skipRelationValidation) {
         await this.relationService.validateRelationsOrThrow(schema, data);
       }
+      if (!options?.skipUserValidation) {
+        await this.userService.validateUsersOrThrow(schema, data);
+      }
     }
     const completionStatus = computeRecordStatus(schema, data);
     const label = await this.computeLabel(schema, data);
@@ -6521,13 +7804,17 @@ var RecordService = class {
     if (!record) {
       return null;
     }
+    const schema = await this.schemaService.getObjectSchema(record.objectId);
+    let enrichedRecord = record;
+    if (!options?.skipFormulas) {
+      enrichedRecord = this.enrichWithFormulas(record, schema);
+    }
     if (options?.includeSchema) {
-      const schema = await this.schemaService.getObjectSchema(record.objectId);
-      const recordWithSchema = record;
+      const recordWithSchema = enrichedRecord;
       recordWithSchema.schema = schema;
       return recordWithSchema;
     }
-    return record;
+    return enrichedRecord;
   }
   /**
    * Get a record by ID or throw if not found
@@ -6588,6 +7875,9 @@ var RecordService = class {
       if (!options?.skipRelationValidation) {
         await this.relationService.validateRelationsOrThrow(schema, data);
       }
+      if (!options?.skipUserValidation) {
+        await this.userService.validateUsersOrThrow(schema, data);
+      }
     }
     const completionStatus = computeRecordStatus(schema, mergedData);
     const label = await this.computeLabel(schema, mergedData);
@@ -6819,6 +8109,46 @@ var RecordService = class {
       timestamp: /* @__PURE__ */ new Date()
     };
   }
+  /**
+   * Enrich a record with computed formula values
+   *
+   * Formula attributes are calculated at read-time from the record's values.
+   * This method adds the computed values to the record's values object.
+   *
+   * @param record - The record to enrich
+   * @param schema - The object schema containing attribute definitions
+   * @returns Record with formula values computed
+   * @internal
+   */
+  enrichWithFormulas(record, schema) {
+    const formulaAttrs = schema.attributes.filter(
+      (a) => a.type === "formula"
+    );
+    if (formulaAttrs.length === 0) {
+      return record;
+    }
+    const enrichedValues = { ...record.values };
+    for (const attr of formulaAttrs) {
+      enrichedValues[attr.name] = evaluateFormulaAttribute(attr, record.values);
+    }
+    return {
+      ...record,
+      values: enrichedValues
+    };
+  }
+  /**
+   * Enrich multiple records with computed formula values
+   * @internal
+   */
+  enrichRecordsWithFormulas(records, schema) {
+    const formulaAttrs = schema.attributes.filter(
+      (a) => a.type === "formula"
+    );
+    if (formulaAttrs.length === 0) {
+      return records;
+    }
+    return records.map((record) => this.enrichWithFormulas(record, schema));
+  }
   /**
    * Permanently delete a record (hard delete)
    *
@@ -6847,11 +8177,18 @@ var RecordService = class {
    * @returns Records and total count
    */
   async listRecords(objectId, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
     if (this.permissionService && this.userId) {
-      const schema = await this.schemaService.getObjectSchema(objectId);
       await this.checkPermission(schema.name, "read");
     }
-    return await this.adapter.objectRecords.list(this.tenantId, objectId, options);
+    const result = await this.adapter.objectRecords.list(this.tenantId, objectId, options);
+    if (!options?.skipFormulas) {
+      return {
+        records: this.enrichRecordsWithFormulas(result.records, schema),
+        total: result.total
+      };
+    }
+    return result;
   }
   /**
    * Search records using full-text search
@@ -6862,11 +8199,18 @@ var RecordService = class {
    * @returns Matching records and total count
    */
   async searchRecords(objectId, query, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
     if (this.permissionService && this.userId) {
-      const schema = await this.schemaService.getObjectSchema(objectId);
       await this.checkPermission(schema.name, "read");
     }
-    return await this.adapter.objectRecords.search(this.tenantId, objectId, query, options);
+    const result = await this.adapter.objectRecords.search(this.tenantId, objectId, query, options);
+    if (!options?.skipFormulas) {
+      return {
+        records: this.enrichRecordsWithFormulas(result.records, schema),
+        total: result.total
+      };
+    }
+    return result;
   }
   /**
    * Validate data against object schema without saving
@@ -6911,6 +8255,231 @@ var RecordService = class {
   }
 };
 
+// src/runtime/services/relation-resolver.service.ts
+var RelationResolverService = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Resolve values from related records for formula evaluation
+   *
+   * Phase 2: Supports 1 level of relation traversal only
+   *
+   * @param record - The source record
+   * @param schema - Schema of the source object
+   * @param relationNames - Names of relation attributes to resolve
+   * @returns Map of relation name to related record's values
+   *
+   * @example
+   * ```typescript
+   * // For an order with company relation
+   * const resolved = await resolver.resolveRelationValues(
+   *   orderRecord,
+   *   orderSchema,
+   *   ["company"]
+   * );
+   * // → { company: { id: "...", name: "Acme Corp", ... } }
+   * ```
+   */
+  async resolveRelationValues(record, schema, relationNames) {
+    const result = {};
+    const relationAttrs = schema.attributes.filter(
+      (a) => a.type === "relation" && relationNames.includes(a.name)
+    );
+    if (relationAttrs.length === 0) {
+      return result;
+    }
+    const idsToFetch = [];
+    const attrIdMap = /* @__PURE__ */ new Map();
+    for (const attr of relationAttrs) {
+      const relatedId = this.extractSingleId(record.values[attr.name]);
+      if (relatedId) {
+        idsToFetch.push(relatedId);
+        attrIdMap.set(relatedId, attr.name);
+      }
+    }
+    if (idsToFetch.length === 0) {
+      return result;
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByIds(idsToFetch);
+    for (const relatedRecord of relatedRecords) {
+      const attrName = attrIdMap.get(relatedRecord.id);
+      if (attrName) {
+        result[attrName] = relatedRecord.values;
+      }
+    }
+    return result;
+  }
+  /**
+   * Resolve relation values for multiple records (batched)
+   *
+   * Optimized for list operations - fetches all related records in one batch
+   *
+   * @param records - Source records
+   * @param schema - Schema of the source object
+   * @param relationNames - Names of relation attributes to resolve
+   * @returns Map of record ID to resolved relations
+   */
+  async resolveRelationValuesForMany(records, schema, relationNames) {
+    const resultMap = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      resultMap.set(record.id, {});
+    }
+    const relationAttrs = schema.attributes.filter(
+      (a) => a.type === "relation" && relationNames.includes(a.name)
+    );
+    if (relationAttrs.length === 0) {
+      return resultMap;
+    }
+    const allIdsToFetch = /* @__PURE__ */ new Set();
+    const recordRelationMap = /* @__PURE__ */ new Map();
+    for (const record of records) {
+      const idToAttr = /* @__PURE__ */ new Map();
+      for (const attr of relationAttrs) {
+        const relatedId = this.extractSingleId(record.values[attr.name]);
+        if (relatedId) {
+          allIdsToFetch.add(relatedId);
+          idToAttr.set(relatedId, attr.name);
+        }
+      }
+      recordRelationMap.set(record.id, idToAttr);
+    }
+    if (allIdsToFetch.size === 0) {
+      return resultMap;
+    }
+    const relatedRecords = await this.adapter.objectRecords.findByIds([...allIdsToFetch]);
+    const relatedRecordMap = new Map(relatedRecords.map((r) => [r.id, r]));
+    for (const record of records) {
+      const result = resultMap.get(record.id);
+      const idToAttr = recordRelationMap.get(record.id);
+      for (const [relatedId, attrName] of idToAttr) {
+        const relatedRecord = relatedRecordMap.get(relatedId);
+        if (relatedRecord) {
+          result[attrName] = relatedRecord.values;
+        }
+      }
+    }
+    return resultMap;
+  }
+  /**
+   * Flatten resolved relations for formula evaluation
+   *
+   * Converts nested structure to dot-notation keys:
+   * { company: { name: "Acme" } } → { "company.name": "Acme" }
+   *
+   * @param resolved - Resolved relations from resolveRelationValues
+   * @returns Flattened values suitable for formula evaluation
+   */
+  flattenResolvedRelations(resolved) {
+    const flat = {};
+    for (const [relationName, values] of Object.entries(resolved)) {
+      for (const [key, value] of Object.entries(values)) {
+        flat[`${relationName}.${key}`] = value;
+      }
+    }
+    return flat;
+  }
+  /**
+   * Extract a single relation ID from a value
+   * Handles both single (string) and multi (array) relations
+   * @internal
+   */
+  extractSingleId(value) {
+    if (typeof value === "string" && value.length > 0) {
+      return value;
+    }
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === "string") {
+      return value[0];
+    }
+    return null;
+  }
+};
+
+// src/runtime/services/rollup-scheduler.ts
+var RollupScheduler = class {
+  constructor(adapter, getSchemaById, options) {
+    this.adapter = adapter;
+    this.getSchemaById = getSchemaById;
+    this.pending = /* @__PURE__ */ new Map();
+    this.rollupService = new RollupService(adapter);
+    this.debounceMs = options?.debounceMs ?? 100;
+    this.maxPending = options?.maxPending ?? 100;
+  }
+  /**
+   * Schedule a rollup recalculation for a parent record
+   *
+   * If the same record is already pending, the timer is reset.
+   * If too many recalculations are pending, triggers an immediate flush.
+   *
+   * @param parentId - ID of the parent record to recalculate
+   * @param parentObjectId - Object ID of the parent
+   * @param tenantId - Tenant ID
+   */
+  scheduleRecalculation(parentId, parentObjectId, tenantId) {
+    const key = `${parentId}:${parentObjectId}`;
+    const existing = this.pending.get(key);
+    if (existing) {
+      clearTimeout(existing.timeout);
+    }
+    const timeout = setTimeout(async () => {
+      await this.executeRecalculation(parentId, parentObjectId, tenantId);
+      this.pending.delete(key);
+    }, this.debounceMs);
+    this.pending.set(key, { parentId, parentObjectId, tenantId, timeout });
+    if (this.pending.size >= this.maxPending) {
+      this.flush();
+    }
+  }
+  /**
+   * Execute all pending recalculations immediately
+   */
+  async flush() {
+    const entries = Array.from(this.pending.entries());
+    for (const [, entry] of entries) {
+      clearTimeout(entry.timeout);
+    }
+    this.pending.clear();
+    const tenantMap = /* @__PURE__ */ new Map();
+    for (const [, entry] of entries) {
+      tenantMap.set(entry.parentId, entry.tenantId);
+    }
+    const allIds = entries.map(([, entry]) => entry.parentId);
+    const records = await this.adapter.objectRecords.findByIds(allIds);
+    for (const record of records) {
+      const schema = await this.getSchemaById(record.objectId);
+      const tenantId = tenantMap.get(record.id);
+      if (schema && tenantId) {
+        await this.rollupService.recalculateAndUpdate(record, schema, tenantId);
+      }
+    }
+  }
+  /**
+   * Execute a single recalculation
+   */
+  async executeRecalculation(parentId, parentObjectId, tenantId) {
+    const record = await this.adapter.objectRecords.findById(parentId);
+    if (!record) return;
+    const schema = await this.getSchemaById(parentObjectId);
+    if (!schema) return;
+    await this.rollupService.recalculateAndUpdate(record, schema, tenantId);
+  }
+  /**
+   * Get number of pending recalculations
+   */
+  get pendingCount() {
+    return this.pending.size;
+  }
+  /**
+   * Clear all pending recalculations without executing them
+   */
+  clear() {
+    for (const [, entry] of this.pending) {
+      clearTimeout(entry.timeout);
+    }
+    this.pending.clear();
+  }
+};
+
 // src/runtime/services/user-profile.service.ts
 var UserProfileService = class {
   constructor(adapter, tenantId, options) {
@@ -7245,7 +8814,7 @@ var ViewService = class {
       throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new ProtectedResourceError("attribute", dbView.name, "modify");
+      throw new ProtectedResourceError("view", dbView.name, "modify");
     }
     const updated = await this.adapter.views.update(viewId, {
       label: input.label,
@@ -7268,7 +8837,7 @@ var ViewService = class {
       throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new ProtectedResourceError("attribute", dbView.name, "delete");
+      throw new ProtectedResourceError("view", dbView.name, "delete");
     }
     await this.adapter.views.delete(viewId);
   }
@@ -7608,7 +9177,8 @@ async function syncAttributes(adapter, nativeObject, dbObject, existingObject, r
       hidden: attr.hidden,
       archived: attr.archived,
       deprecated: attr.deprecated,
-      defaultValue: attr.defaultValue,
+      // Formula and rollup attributes don't have defaultValue
+      defaultValue: "defaultValue" in attr ? attr.defaultValue : void 0,
       config: extractAttributeConfig(attr)
     });
     if (existingAttr) {
@@ -7690,6 +9260,8 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   GeocodingService,
   GlobalSearchService,
   GroupBuilder,
+  InvalidPathError,
+  MaxDepthExceededError,
   NO_VALUE_OPERATORS,
   NoopGeocodingAdapter,
   NoopHookRegistry,
@@ -7706,8 +9278,11 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   RecordNotFoundError,
   RecordReferencedError,
   RecordService,
+  RelationResolverService,
   RelationService,
   RoleNotFoundError,
+  RollupScheduler,
+  RollupService,
   SYSTEM_RESOURCES,
   SYSTEM_RESOURCE_LABELS,
   SchemaError,
@@ -7717,6 +9292,7 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   TableTabConfig,
   UserProfileNotFoundError,
   UserProfileService,
+  UserService,
   ValidationError,
   ViewBuilder,
   ViewService,
@@ -7731,6 +9307,7 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   createDateValidator,
   createDraftValidator,
   createFileValidator,
+  createFormulaValidator,
   createLocationValidator,
   createMockAdapter,
   createMultiRelationValidator,
@@ -7740,6 +9317,8 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   createPhoneValidator,
   createRatingValidator,
   createRelationValidator,
+  createRollupHooks,
+  createRollupValidator,
   createSelectValidator,
   createSingleRelationValidator,
   createStatusValidator,
@@ -7751,18 +9330,34 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   date,
   dateConfigSchema,
   enrichValuesWithSelectLabels,
+  evaluateFormula,
+  evaluateFormulaAttribute,
+  evaluateFormulaAttributeWithRelations,
+  evaluateFormulaWithRelations,
+  evaluateFormulaWithResult,
   extractAttributeNames,
+  extractFormulaVariables,
+  extractRelationNames,
+  extractRelationReferences,
   file,
   fileConfigSchema,
+  flattenRelationsForEval,
   flow,
   formatAttributeValue,
+  formatFormulaResult,
+  formula,
+  formulaConfigSchema,
   generateId,
   generatePrefixedId,
   getAttributeConfigSchema,
   getMissingRequiredAttributes,
+  getPathDepth,
+  getRelationPath,
   getSyncPreview,
+  getTargetAttributeName,
   getViewSyncPreview,
   group,
+  hasRelationReferences,
   isActivityTab,
   isAdvancedFilterState,
   isCustomTab,
@@ -7788,14 +9383,21 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   numberConfigSchema,
   object,
   parseAttributeConfig,
+  parsePath,
+  pathHasManyCardinality,
   phone,
   phoneConfigSchema,
   rating,
   ratingConfigSchema,
+  registerAllRollupHooks,
   registry,
   relation,
   relationConfigSchema,
   renderLabelExpression,
+  resolveMultiplePaths,
+  resolveSingleValue,
+  rollup,
+  rollupConfigSchema,
   safeParseAttributeConfig,
   select,
   selectConfigSchema,
@@ -7812,14 +9414,17 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   timestampConfigSchema,
   toAdvancedFilterState,
   toSimpleFilterState,
+  traversePath,
   user,
   userConfigSchema,
   validateAttribute,
   validateAttributeConfig,
   validateDraft,
   validateDraftOrThrow,
+  validateFormulaExpression,
   validateObject,
   validateObjectOrThrow,
+  validatePath,
   verifyNativeObjectsSync,
   verifyNativeViewsSync,
   view,