@stndrds/schema 0.1.0-alpha.63 → 0.1.0-alpha.65

package/dist/{chunk-KMAKDHCL.js → chunk-TOTUS3YS.js}

@@ -10,6 +10,7 @@ var _chunkNEVERCM3js = require('./chunk-NEVERCM3.js');
 
 
 
+
 var _chunkU4AB53AMjs = require('./chunk-U4AB53AM.js');
 
 
@@ -4133,7 +4134,6 @@ function createMockRelationAttributesRepository(stores) {
       }
       const results = [];
       for (const item of items) {
-        const _key = `${context.tenantId}:${item.fromObject}:${item.fromId}:${item.fromAttribute}:${item.toId}`;
         const existing = Array.from(stores.relationAttributes.values()).find(
           (row) => row.tenantId === context.tenantId && row.fromObject === item.fromObject && row.fromId === item.fromId && row.fromAttribute === item.fromAttribute && row.toId === item.toId
         );
@@ -4180,6 +4180,36 @@ function createMockRelationAttributesRepository(stores) {
         (row) => row.tenantId === context.tenantId && row.toId === toId
       );
     },
+    async findBySourceBatch(fromObject, fromIds, fromAttribute) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      return Array.from(stores.relationAttributes.values()).filter(
+        (row) => row.tenantId === context.tenantId && row.fromObject === fromObject && fromIds.includes(row.fromId) && row.fromAttribute === fromAttribute
+      );
+    },
+    async findByTargetBatch(toIds) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      return Array.from(stores.relationAttributes.values()).filter(
+        (row) => row.tenantId === context.tenantId && toIds.includes(row.toId)
+      );
+    },
+    async deleteBySourceAndTarget(fromObject, fromId, fromAttribute, toId) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      const toDelete = Array.from(stores.relationAttributes.entries()).filter(
+        ([_id, row]) => row.tenantId === context.tenantId && row.fromObject === fromObject && row.fromId === fromId && row.fromAttribute === fromAttribute && row.toId === toId
+      );
+      for (const [id] of toDelete) {
+        stores.relationAttributes.delete(id);
+      }
+    },
     async deleteBySource(fromObject, fromId, fromAttribute) {
       const context = getContext2();
       if (!context) {
@@ -5244,92 +5274,6 @@ var PolicyRegistry = class {
 };
 var defaultPolicyRegistry = new PolicyRegistry();
 
-// src/runtime/policies/notes.policy.ts
-var notesPolicy = {
-  objectName: "notes",
-  /**
-   * Inject visibility filter for list/search operations.
-   *
-   * Creates: (visibility = 'shared') OR (createdBy = userId)
-   *
-   * This filters at the SQL level for better performance.
-   * canAccessRecord provides defense-in-depth as a secondary check.
-   *
-   * Note: When user filters exist, we preserve linkedTo filter (common for notes)
-   * but the visibility OR filter takes precedence. Full filter merging would require
-   * AdvancedFilterState support in the adapter.
-   */
-  applyListFilter(ctx, options) {
-    const visibilityRules = [
-      { attribute: "visibility", operator: "is", value: "shared" },
-      { attribute: "createdBy", operator: "is", value: ctx.userId }
-    ];
-    if (!_optionalChain([options, 'optionalAccess', _113 => _113.filters]) || options.filters.rules.length === 0) {
-      return {
-        ...options,
-        filters: { combinator: "or", rules: visibilityRules }
-      };
-    }
-    const linkedToFilter = options.filters.rules.find((r) => r.attribute === "linkedTo");
-    if (linkedToFilter) {
-      return {
-        ...options,
-        filters: {
-          combinator: "and",
-          rules: [linkedToFilter]
-        }
-      };
-    }
-    return {
-      ...options,
-      filters: { combinator: "or", rules: visibilityRules }
-    };
-  },
-  /**
-   * Check if user can access a specific note.
-   *
-   * Rules:
-   * - Shared notes: accessible by anyone in the tenant
-   * - Private notes: only accessible by the author (createdBy)
-   */
-  canAccessRecord(ctx, record) {
-    const visibility = record.values.visibility;
-    if (visibility === "shared") {
-      return true;
-    }
-    if (visibility === "private") {
-      return record.createdBy === ctx.userId;
-    }
-    return false;
-  },
-  /**
-   * Check if user can modify a note.
-   *
-   * Rules:
-   * - Private notes: only the author can modify
-   * - Shared notes: anyone can modify
-   */
-  canModifyRecord(ctx, record) {
-    const visibility = record.values.visibility;
-    if (visibility === "private") {
-      return record.createdBy === ctx.userId;
-    }
-    return true;
-  },
-  /**
-   * Check if user can delete a note.
-   *
-   * Rules:
-   * - Only the author (createdBy) can delete a note, regardless of visibility
-   */
-  canDeleteRecord(ctx, record) {
-    return record.createdBy === ctx.userId;
-  }
-};
-
-// src/runtime/policies/index.ts
-defaultPolicyRegistry.register(notesPolicy);
-
 // src/runtime/services/base.service.ts
 var BaseService = class {
   constructor(adapter) {
@@ -5410,7 +5354,7 @@ var BaseService = class {
    * @param key - Cache key to invalidate
    */
   async invalidateCache(key) {
-    await _optionalChain([this, 'access', _114 => _114.cache, 'optionalAccess', _115 => _115.delete, 'call', _116 => _116(key)]);
+    await _optionalChain([this, 'access', _113 => _113.cache, 'optionalAccess', _114 => _114.delete, 'call', _115 => _115(key)]);
   }
   /**
    * Invalidate all cache keys matching a pattern.
@@ -5418,7 +5362,7 @@ var BaseService = class {
    * @param pattern - Glob-style pattern (e.g., "schema:tenant-123:*")
    */
   async invalidateCachePattern(pattern) {
-    await _optionalChain([this, 'access', _117 => _117.cache, 'optionalAccess', _118 => _118.deletePattern, 'call', _119 => _119(pattern)]);
+    await _optionalChain([this, 'access', _116 => _116.cache, 'optionalAccess', _117 => _117.deletePattern, 'call', _118 => _118(pattern)]);
   }
   /**
    * Invalidate all cached lists for a resource.
@@ -5543,6 +5487,23 @@ var RELATION_TARGET_ANY = "*";
 function isUniversalRelation(attr) {
   return attr.targets.length === 1 && attr.targets[0].object === RELATION_TARGET_ANY;
 }
+function isBilateralRelation(attr) {
+  return attr.bilateral !== void 0;
+}
+function inferInverseCardinality(cardinality) {
+  return cardinality === "one" ? "many" : "many";
+}
+
+// src/types/relation-properties.ts
+var FORBIDDEN_PROPERTY_TYPES = [
+  "formula",
+  "rollup",
+  "relation",
+  "file",
+  "user",
+  "document",
+  "richtext"
+];
 
 // src/builders/attribute-validators.ts
 
@@ -5616,17 +5577,17 @@ function validateOptions(options, attributeName) {
   const ids = /* @__PURE__ */ new Set();
   const values = /* @__PURE__ */ new Set();
   for (const option of options) {
-    if (!_optionalChain([option, 'access', _120 => _120.id, 'optionalAccess', _121 => _121.trim, 'call', _122 => _122()])) {
+    if (!_optionalChain([option, 'access', _119 => _119.id, 'optionalAccess', _120 => _120.trim, 'call', _121 => _121()])) {
       throw new Error(
         `[AttributeBuilder] Option in "${attributeName}" has an empty or missing id.`
       );
     }
-    if (!_optionalChain([option, 'access', _123 => _123.value, 'optionalAccess', _124 => _124.trim, 'call', _125 => _125()])) {
+    if (!_optionalChain([option, 'access', _122 => _122.value, 'optionalAccess', _123 => _123.trim, 'call', _124 => _124()])) {
       throw new Error(
         `[AttributeBuilder] Option "${option.id}" in "${attributeName}" has an empty or missing value.`
       );
     }
-    if (!_optionalChain([option, 'access', _126 => _126.label, 'optionalAccess', _127 => _127.trim, 'call', _128 => _128()])) {
+    if (!_optionalChain([option, 'access', _125 => _125.label, 'optionalAccess', _126 => _126.trim, 'call', _127 => _127()])) {
       throw new Error(
         `[AttributeBuilder] Option "${option.id}" in "${attributeName}" has an empty or missing label.`
       );
@@ -5649,292 +5610,6 @@ function validateOptions(options, attributeName) {
   }
 }
 
-// src/types/relation-properties.ts
-var FORBIDDEN_PROPERTY_TYPES = [
-  "formula",
-  "rollup",
-  "relation",
-  "file",
-  "user",
-  "document",
-  "richtext"
-];
-
-// src/builders/property-schema-builder.ts
-var PropertySchemaBuilder = class {
-  constructor() {
-    this.definitions = [];
-  }
-  /**
-   * Add a property to the schema
-   * The type of property is automatically detected based on the builder methods used
-   */
-  add(name, configure) {
-    const builder = new PropertyTypeBuilder(name);
-    const configured = configure(builder);
-    const definition = configured.build();
-    this.definitions.push(definition);
-    return this;
-  }
-  /**
-   * Build the final PropertySchema
-   */
-  build() {
-    return {
-      definitions: this.definitions
-    };
-  }
-};
-var PropertyTypeBuilder = class {
-  constructor(name) {
-    this.name = name;
-  }
-  // Explicit type constructors
-  text() {
-    return new TextPropertyBuilder(this.name);
-  }
-  textarea() {
-    return new TextareaPropertyBuilder(this.name);
-  }
-  number() {
-    return new NumberPropertyBuilder(this.name);
-  }
-  checkbox() {
-    return new CheckboxPropertyBuilder(this.name);
-  }
-  date() {
-    return new DatePropertyBuilder(this.name);
-  }
-  phone() {
-    return new PhonePropertyBuilder(this.name);
-  }
-  currency() {
-    return new CurrencyPropertyBuilder(this.name);
-  }
-  status() {
-    return new StatusPropertyBuilder(this.name);
-  }
-  select() {
-    return new SelectPropertyBuilder(this.name);
-  }
-  multiselect() {
-    return new MultiselectPropertyBuilder(this.name);
-  }
-  rating() {
-    return new RatingPropertyBuilder(this.name);
-  }
-  location() {
-    return new LocationPropertyBuilder(this.name);
-  }
-};
-var BasePropertyBuilder = class {
-  constructor(name) {
-    this.definition = { name };
-  }
-  /**
-   * Set the label
-   */
-  label(label) {
-    this.definition.label = label;
-    return this;
-  }
-  /**
-   * Mark as required
-   */
-  required() {
-    this.definition.required = true;
-    return this;
-  }
-  /**
-   * Set description
-   */
-  description(description) {
-    this.definition.description = description;
-    return this;
-  }
-  /**
-   * Build the final definition
-   */
-  build() {
-    return this.definition;
-  }
-};
-var TextPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "text";
-  }
-  minLength(value) {
-    this.definition.minLength = value;
-    return this;
-  }
-  maxLength(value) {
-    this.definition.maxLength = value;
-    return this;
-  }
-  pattern(pattern) {
-    this.definition.pattern = pattern;
-    return this;
-  }
-  placeholder(value) {
-    this.definition.placeholder = value;
-    return this;
-  }
-};
-var TextareaPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "textarea";
-  }
-  minLength(value) {
-    this.definition.minLength = value;
-    return this;
-  }
-  maxLength(value) {
-    this.definition.maxLength = value;
-    return this;
-  }
-  placeholder(value) {
-    this.definition.placeholder = value;
-    return this;
-  }
-};
-var NumberPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "number";
-  }
-  min(value) {
-    this.definition.min = value;
-    return this;
-  }
-  max(value) {
-    this.definition.max = value;
-    return this;
-  }
-  decimal(places) {
-    this.definition.decimal = places;
-    return this;
-  }
-  integer() {
-    this.definition.integer = true;
-    return this;
-  }
-  placeholder(value) {
-    this.definition.placeholder = value;
-    return this;
-  }
-};
-var CheckboxPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "checkbox";
-  }
-};
-var DatePropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "date";
-  }
-  includeTime() {
-    this.definition.includeTime = true;
-    return this;
-  }
-  min(date2) {
-    this.definition.min = date2;
-    return this;
-  }
-  max(date2) {
-    this.definition.max = date2;
-    return this;
-  }
-};
-var PhonePropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "phone";
-  }
-};
-var CurrencyPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "currency";
-  }
-  currency(code) {
-    this.definition.currency = code;
-    return this;
-  }
-  min(value) {
-    this.definition.min = value;
-    return this;
-  }
-  max(value) {
-    this.definition.max = value;
-    return this;
-  }
-};
-var StatusPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "status";
-  }
-  options(options) {
-    this.definition.options = options;
-    return this;
-  }
-};
-var SelectPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "select";
-  }
-  options(options) {
-    this.definition.options = options;
-    return this;
-  }
-};
-var MultiselectPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "multiselect";
-  }
-  options(options) {
-    this.definition.options = options;
-    return this;
-  }
-  maxSelections(value) {
-    this.definition.maxSelections = value;
-    return this;
-  }
-};
-var RatingPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "rating";
-  }
-  max(value) {
-    this.definition.max = value;
-    return this;
-  }
-  icon(icon) {
-    this.definition.icon = icon;
-    return this;
-  }
-};
-var LocationPropertyBuilder = class extends BasePropertyBuilder {
-  constructor(name) {
-    super(name);
-    this.definition.type = "location";
-  }
-};
-function validatePropertyType(type) {
-  if (FORBIDDEN_PROPERTY_TYPES.includes(type)) {
-    throw new Error(
-      `Property type "${type}" is not supported in .qualifyWith(). Only simple types (text, number, date, select, etc.) are allowed. Complex types (formula, rollup, relation, file, user, document) would require duplicating backend behavior.`
-    );
-  }
-}
-
 // src/builders/attribute-builders.ts
 var BaseAttributeBuilder = class {
   constructor(type, name, label) {
@@ -6010,8 +5685,8 @@ var BaseAttributeBuilder = class {
   featureGate(flagName, options) {
     this.attr.featureGate = {
       flag: flagName,
-      expectedValue: _optionalChain([options, 'optionalAccess', _129 => _129.expectedValue]),
-      fallback: _optionalChain([options, 'optionalAccess', _130 => _130.fallback])
+      expectedValue: _optionalChain([options, 'optionalAccess', _128 => _128.expectedValue]),
+      fallback: _optionalChain([options, 'optionalAccess', _129 => _129.fallback])
     };
     return this;
   }
@@ -6443,12 +6118,7 @@ var UserAttributeBuilder = class extends BaseAttributeBuilder {
 function user(config) {
   return new UserAttributeBuilder(config.name, config.label);
 }
-var SingleRelationAttributeBuilder = class extends BaseAttributeBuilder {
-  constructor(name, label) {
-    super("relation", name, label);
-    this.attr.cardinality = "one";
-    this.attr.targets = [];
-  }
+var BaseRelationAttributeBuilder = class extends BaseAttributeBuilder {
   /**
    * Add a target object that can be linked
    * @param objectName - Name of the object (e.g., "companies")
@@ -6459,111 +6129,110 @@ var SingleRelationAttributeBuilder = class extends BaseAttributeBuilder {
       object: objectName,
       ...options
     };
-    _optionalChain([this, 'access', _131 => _131.attr, 'access', _132 => _132.targets, 'optionalAccess', _133 => _133.push, 'call', _134 => _134(target)]);
+    _optionalChain([this, 'access', _130 => _130.attr, 'access', _131 => _131.targets, 'optionalAccess', _132 => _132.push, 'call', _133 => _133(target)]);
     return this;
   }
   /**
    * Allow linking to any object in the tenant (universal polymorphic)
    * Creates a relation with `targets: [{ object: "*" }]`
-   *
-   * @example
-   * ```typescript
-   * relation({ name: "linkedTo", label: "Linked To" })
-   *   .toAny()
-   *   .hidden()
-   * ```
    */
   toAny() {
     this.attr.targets = [{ object: RELATION_TARGET_ANY }];
     return this;
   }
   /**
-   * Convert to a multi-relation (cardinality: "many")
-   */
-  many() {
-    const multiBuilder = new MultiRelationAttributeBuilder(
-      this.attr.name,
-      _nullishCoalesce(this.attr.label, () => ( "")),
-      {
-        targets: this.attr.targets,
-        isRequired: this.attr.required
-      }
-    );
-    return multiBuilder;
-  }
-  /**
-   * Add properties to qualify the relation
-   * Must be called AFTER .to() to ensure targets are defined
+   * Add properties to qualify the relation using existing attribute builders.
+   * Must be called AFTER .to() to ensure targets are defined.
    *
    * @example
    * ```typescript
-   * relation({ name: "mainCompany", label: "Main Company" })
-   *   .to("companies")
-   *   .qualifyWith(props => props
-   *     .add("role", select => select.options([...]).required())
-   *     .add("shares", number => number.min(0))
+   * relation({ name: "companies", label: "Companies" })
+   *   .to("companies").many()
+   *   .qualifyWith(
+   *     select({ name: "role", label: "Role" }).options([...]).required(),
+   *     number({ name: "shares", label: "Shares" }).min(0),
    *   )
    * ```
    */
-  qualifyWith(configure) {
+  qualifyWith(...builders) {
     const targets = this.attr.targets;
     if (!targets || targets.length === 0) {
       throw new Error(
-        '.qualifyWith() must be called AFTER .to(). Example: relation({ name: "mainCompany" }).to("companies").qualifyWith(...)'
+        '.qualifyWith() must be called AFTER .to(). Example: relation({ name: "companies" }).to("companies").qualifyWith(...)'
       );
     }
-    const builder = new PropertySchemaBuilder();
-    const schema = configure(builder).build();
-    this.attr.properties = schema;
-    return this;
-  }
-  required() {
-    this.setRequired(true);
+    const definitions = builders.map((builder) => {
+      const attr = builder.build();
+      if (FORBIDDEN_PROPERTY_TYPES.includes(attr.type)) {
+        throw new Error(`Property type "${attr.type}" is not supported in .qualifyWith()`);
+      }
+      return attr;
+    });
+    this.attr.properties = { definitions };
     return this;
   }
-  optional() {
-    this.setRequired(false);
-    return this;
+  /**
+   * Enable bilateral synchronization for this relation.
+   * Must be called AFTER .to() to ensure targets are defined.
+   */
+  bilateral(config) {
+    const targets = this.attr.targets;
+    if (!targets || targets.length === 0) {
+      throw new Error(
+        '.bilateral() must be called AFTER .to(). Example: relation({ name: "company" }).to("companies").bilateral({ ... })'
+      );
+    }
+    if (targets.length > 1) {
+      throw new Error(
+        "Bilateral relations are not supported for polymorphic relations (multiple .to() targets)."
+      );
+    }
+    if (isUniversalRelation(this.attr)) {
+      throw new Error("Bilateral relations are not supported for universal relations (.toAny()).");
+    }
+    this.attr.bilateral = config;
+    return this;
   }
 };
-var MultiRelationAttributeBuilder = class extends BaseAttributeBuilder {
-  constructor(name, label, initOptions) {
+var SingleRelationAttributeBuilder = class extends BaseRelationAttributeBuilder {
+  constructor(name, label) {
     super("relation", name, label);
-    this.attr.cardinality = "many";
-    this.attr.targets = _nullishCoalesce(_optionalChain([initOptions, 'optionalAccess', _135 => _135.targets]), () => ( []));
-    this.attr.defaultValue = [];
-    if (_optionalChain([initOptions, 'optionalAccess', _136 => _136.isRequired])) {
-      this.setRequired(true);
-    }
+    this.attr.cardinality = "one";
+    this.attr.targets = [];
   }
   /**
-   * Add a target object that can be linked
-   * @param objectName - Name of the object (e.g., "companies")
-   * @param options - Display template and filter options
+   * Convert to a multi-relation (cardinality: "many")
    */
-  to(objectName, options) {
-    const target = {
-      object: objectName,
-      ...options
-    };
-    _optionalChain([this, 'access', _137 => _137.attr, 'access', _138 => _138.targets, 'optionalAccess', _139 => _139.push, 'call', _140 => _140(target)]);
+  many() {
+    const multiBuilder = new MultiRelationAttributeBuilder(
+      this.attr.name,
+      _nullishCoalesce(this.attr.label, () => ( "")),
+      {
+        targets: this.attr.targets,
+        isRequired: this.attr.required
+      }
+    );
+    return multiBuilder;
+  }
+  required() {
+    this.setRequired(true);
     return this;
   }
-  /**
-   * Allow linking to any object in the tenant (universal polymorphic)
-   * Creates a relation with `targets: [{ object: "*" }]`
-   *
-   * @example
-   * ```typescript
-   * relation({ name: "linkedItems", label: "Linked Items" })
-   *   .toAny()
-   *   .many()
-   * ```
-   */
-  toAny() {
-    this.attr.targets = [{ object: RELATION_TARGET_ANY }];
+  optional() {
+    this.setRequired(false);
     return this;
   }
+};
+var MultiRelationAttributeBuilder = class extends BaseRelationAttributeBuilder {
+  constructor(name, label, initOptions) {
+    super("relation", name, label);
+    this.attr.cardinality = "many";
+    this.attr.targets = _nullishCoalesce(_optionalChain([initOptions, 'optionalAccess', _134 => _134.targets]), () => ( []));
+    this.attr.defaultValue = [];
+    if (_optionalChain([initOptions, 'optionalAccess', _135 => _135.isRequired])) {
+      this.setRequired(true);
+    }
+  }
   /**
    * Set minimum number of relations required
    */
@@ -6578,33 +6247,6 @@ var MultiRelationAttributeBuilder = class extends BaseAttributeBuilder {
     this.attr.maxItems = count;
     return this;
   }
-  /**
-   * Add properties to qualify the relation
-   * Must be called AFTER .to() or .many() to ensure targets are defined
-   *
-   * @example
-   * ```typescript
-   * relation({ name: "companies", label: "Companies" })
-   *   .to("companies")
-   *   .many()
-   *   .qualifyWith(props => props
-   *     .add("role", select => select.options([...]).required())
-   *     .add("shares", number => number.min(0))
-   *   )
-   * ```
-   */
-  qualifyWith(configure) {
-    const targets = this.attr.targets;
-    if (!targets || targets.length === 0) {
-      throw new Error(
-        '.qualifyWith() must be called AFTER .to() or .many(). Example: relation({ name: "companies" }).to("companies").many().qualifyWith(...)'
-      );
-    }
-    const builder = new PropertySchemaBuilder();
-    const schema = configure(builder).build();
-    this.attr.properties = schema;
-    return this;
-  }
   required() {
     this.setRequired(true);
     return this;
@@ -6672,8 +6314,9 @@ var FormulaAttributeBuilder = class extends BaseAttributeBuilder {
   // 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;
+    throw new Error(
+      "Formula attributes cannot be required: they are computed read-only values. Remove .required() from this attribute definition."
+    );
   }
   // biome-ignore lint/suspicious/noExplicitAny: intentional override
   optional() {
@@ -6747,8 +6390,9 @@ var RollupAttributeBuilder = class extends BaseAttributeBuilder {
   // 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;
+    throw new Error(
+      "Rollup attributes cannot be required: they are computed read-only values. Remove .required() from this attribute definition."
+    );
   }
   // biome-ignore lint/suspicious/noExplicitAny: intentional override
   optional() {
@@ -7026,7 +6670,7 @@ var GroupBuilder = class {
    */
   fields(...names) {
     for (const name of names) {
-      _optionalChain([this, 'access', _141 => _141.data, 'access', _142 => _142.fields, 'optionalAccess', _143 => _143.push, 'call', _144 => _144({ attribute: name })]);
+      _optionalChain([this, 'access', _136 => _136.data, 'access', _137 => _137.fields, 'optionalAccess', _138 => _138.push, 'call', _139 => _139({ attribute: name })]);
     }
     return this;
   }
@@ -7035,7 +6679,7 @@ var GroupBuilder = class {
    * @example .field("name", { span: 8, readOnly: true })
    */
   field(attribute, options) {
-    _optionalChain([this, 'access', _145 => _145.data, 'access', _146 => _146.fields, 'optionalAccess', _147 => _147.push, 'call', _148 => _148({ attribute, ...options })]);
+    _optionalChain([this, 'access', _140 => _140.data, 'access', _141 => _141.fields, 'optionalAccess', _142 => _142.push, 'call', _143 => _143({ attribute, ...options })]);
     return this;
   }
   /**
@@ -7044,7 +6688,7 @@ var GroupBuilder = class {
    * @example .attributeGroup({ id: "address", label: "Address", attributes: ["street", "city", "postal_code"], displayTemplate: "{street}, {city}" })
    */
   attributeGroup(config, options) {
-    _optionalChain([this, 'access', _149 => _149.data, 'access', _150 => _150.fields, 'optionalAccess', _151 => _151.push, 'call', _152 => _152({ attributeGroup: config, ...options })]);
+    _optionalChain([this, 'access', _144 => _144.data, 'access', _145 => _145.fields, 'optionalAccess', _146 => _146.push, 'call', _147 => _147({ attributeGroup: config, ...options })]);
     return this;
   }
   /**
@@ -7063,7 +6707,87 @@ var GroupBuilder = class {
     return this.data;
   }
 };
-var BaseTableTabConfig = class {
+var RelationGroupBuilder = class {
+  constructor(id, label, attribute) {
+    this.data = { type: "relation" };
+    this.data.id = id;
+    this.data.label = label;
+    this.data.attribute = attribute;
+  }
+  /**
+   * Set group description
+   */
+  description(value) {
+    this.data.description = value;
+    return this;
+  }
+  /**
+   * Make group collapsible
+   * @param collapsed - Initial collapsed state (default: false)
+   */
+  collapsible(collapsed = false) {
+    this.data.collapsible = true;
+    this.data.collapsed = collapsed;
+    return this;
+  }
+  /**
+   * Set display order
+   */
+  order(value) {
+    this.data.order = value;
+    return this;
+  }
+  /**
+   * Set columns to display in the relations table
+   * @example .columns("name", "email", "phone")
+   */
+  columns(...names) {
+    this.data.columns = names;
+    return this;
+  }
+  /**
+   * Set the group as read-only (no add/remove/edit)
+   */
+  readOnly(value = true) {
+    this.data.readOnly = value;
+    return this;
+  }
+  /**
+   * Allow creating new related records inline
+   */
+  allowCreate(value = true) {
+    this.data.allowCreate = value;
+    return this;
+  }
+  /**
+   * Enable two-level traversal (through mode).
+   * Parent rows become grouping headers; sub-rows from `attribute` are the primary display.
+   *
+   * @param attribute - Relation attribute on the first-level target object
+   * @example .through("companies") — display companies linked via each member
+   */
+  through(attribute) {
+    this.data.through = { attribute };
+    return this;
+  }
+  /**
+   * Build the relation group definition
+   */
+  build() {
+    if (!this.data.id) {
+      throw new Error("[RelationGroupBuilder] id is required");
+    }
+    if (!this.data.label) {
+      throw new Error("[RelationGroupBuilder] label is required");
+    }
+    if (!this.data.attribute) {
+      throw new Error("[RelationGroupBuilder] attribute is required");
+    }
+    return this.data;
+  }
+};
+var TableTabConfig = class {
+  /** @internal */
   constructor(view2, tabData) {
     this.view = view2;
     this.tabData = tabData;
@@ -7141,6 +6865,29 @@ var BaseTableTabConfig = class {
     this.tabData.sorts.push({ attribute, direction });
     return this;
   }
+  /**
+   * Traverse a 2nd-level relation to display nested data.
+   * When active, `tab.columns` stores the 2nd-level object's attribute names.
+   *
+   * @param attribute - Relation attribute on the first-level target object
+   * @example .table("members").through("companies").columns(["name", "sector"])
+   */
+  through(attribute) {
+    this.tabData.through = { attribute };
+    return this;
+  }
+  /**
+   * Show _source and _target columns in flattened (through) view
+   */
+  showSourceTarget(value = true) {
+    if (!this.tabData.through) {
+      throw new Error(
+        `[TableTabConfig] showSourceTarget() requires through() to be called first for tab "${this.tabData.name}"`
+      );
+    }
+    this.tabData.through.showSourceTarget = value;
+    return this;
+  }
   /**
    * Continue building with a new tab
    */
@@ -7169,31 +6916,6 @@ var BaseTableTabConfig = class {
     this.view._addTab(this.tabData);
   }
 };
-var DirectTableTabConfig = class extends BaseTableTabConfig {
-  /** @internal */
-  constructor(view2, base, relationAttribute) {
-    super(view2, {
-      ...base,
-      type: "table",
-      relationMode: "direct",
-      relationAttribute,
-      columns: []
-    });
-  }
-};
-var InverseTableTabConfig = class extends BaseTableTabConfig {
-  /** @internal */
-  constructor(view2, base, sourceObject, relationAttribute) {
-    super(view2, {
-      ...base,
-      type: "table",
-      relationMode: "inverse",
-      sourceObject,
-      relationAttribute,
-      columns: []
-    });
-  }
-};
 var CustomTabConfig = class {
   /** @internal */
   constructor(view2, base, component) {
@@ -7229,24 +6951,17 @@ var CustomTabConfig = class {
     return this.view.build();
   }
 };
-var NotesTabConfig = class {
+var RichtextTabConfig = class {
   /** @internal */
-  constructor(view2, base) {
+  constructor(view2, base, attribute) {
     this.view = view2;
-    this.tabData = { ...base, type: "notes" };
-  }
-  /**
-   * Show only private notes of the current user
-   */
-  privateOnly() {
-    this.tabData.privateOnly = true;
-    return this;
+    this.tabData = { ...base, type: "richtext", attribute };
   }
   /**
-   * Allow creating new notes from this tab
+   * Set a text attribute to display as an editable title above the editor
    */
-  create() {
-    this.tabData.allowCreate = true;
+  titleAttribute(name) {
+    this.tabData.titleAttribute = name;
     return this;
   }
   /**
@@ -7469,7 +7184,7 @@ var TabBuilder = class {
   // ─────────────────────────────────────────────────────────────────────────
   /**
    * Create a form tab with groups
-   * @example .form(group("info", "Info").fields("name", "email"))
+   * @example .form(group("info", "Info").fields("name", "email"), relationGroup("contacts", "Contacts", "contacts"))
    */
   form(...groups) {
     if (groups.length === 0) {
@@ -7480,32 +7195,44 @@ var TabBuilder = class {
     const tab = {
       ...this.base,
       type: "form",
-      groups: groups.map((g) => g instanceof GroupBuilder ? g.build() : g)
+      groups: groups.map(
+        (g) => g instanceof GroupBuilder || g instanceof RelationGroupBuilder ? g.build() : g
+      )
     };
     return this.view._addTab(tab);
   }
   /**
-   * Create a direct table tab for a relation attribute on the current object
+   * Create a table tab for a relation attribute on the current object
    *
    * Use this when the current object has a relation attribute pointing to another object.
    *
    * @param relationAttribute - Name of the relation attribute on the current object
-   * @example .table("members").columns("name", "email").crud()  // Show users from Project.members
+   * @example .table("members").columns("name", "email").crud()
    */
   table(relationAttribute) {
-    return new DirectTableTabConfig(this.view, this.base, relationAttribute);
+    return new TableTabConfig(this.view, {
+      ...this.base,
+      type: "table",
+      source: { type: "relation", attribute: relationAttribute },
+      columns: []
+    });
   }
   /**
-   * Create an inverse table tab showing records from another object that have a relation to us
+   * Create a table tab showing records from another object that have a relation to us
    *
    * Use this when another object has a relation attribute pointing to the current object.
    *
    * @param sourceObject - Name of the object that has the relation to us
    * @param relationAttribute - Name of the relation attribute on the source object
-   * @example .tableFrom("contacts", "company").columns("firstName", "lastName")  // Show contacts where Contact.company = this
+   * @example .tableFrom("contacts", "company").columns("firstName", "lastName")
    */
   tableFrom(sourceObject, relationAttribute) {
-    return new InverseTableTabConfig(this.view, this.base, sourceObject, relationAttribute);
+    return new TableTabConfig(this.view, {
+      ...this.base,
+      type: "table",
+      source: { type: "inverse", object: sourceObject, attribute: relationAttribute },
+      columns: []
+    });
   }
   /**
    * Create a custom tab with a component
@@ -7515,11 +7242,11 @@ var TabBuilder = class {
     return new CustomTabConfig(this.view, this.base, component);
   }
   /**
-   * Create a notes tab
-   * @example .notes().create().privateOnly()
+   * Create a richtext tab for a richtext attribute
+   * @example .richtext("content").titleAttribute("title")
    */
-  notes() {
-    return new NotesTabConfig(this.view, this.base);
+  richtext(attribute) {
+    return new RichtextTabConfig(this.view, this.base, attribute);
   }
   /**
    * Create an activity tab
@@ -7606,6 +7333,16 @@ var DetailViewBuilder = class {
     this.data.metadata = value;
     return this;
   }
+  /**
+   * Configure a side panel with flat attribute fields displayed alongside tab content.
+   * Not available for modal layout.
+   *
+   * @example .sidePanel({ attributes: ["visibility", "linkedTo"] })
+   */
+  sidePanel(config) {
+    this.data.sidePanel = config;
+    return this;
+  }
   /**
    * Start building a new tab
    */
@@ -7650,10 +7387,14 @@ var DetailViewBuilder = class {
       if (this.data.tabs[0].type !== "form") {
         throw new Error("[DetailViewBuilder] Modal views must have a form tab");
       }
+      if (this.data.sidePanel) {
+        throw new Error("[DetailViewBuilder] Modal views cannot have a side panel");
+      }
     }
     const config = {
       layout: this.data.layout,
-      tabs: this.data.tabs
+      tabs: this.data.tabs,
+      sidePanel: this.data.sidePanel
     };
     return {
       name: this.data.name,
@@ -7988,6 +7729,9 @@ function listView(name, label) {
 function group(id, label) {
   return new GroupBuilder(id, label);
 }
+function relationGroup(id, label, attribute) {
+  return new RelationGroupBuilder(id, label, attribute);
+}
 
 // src/builders/workflow-builder.ts
 
@@ -8012,8 +7756,8 @@ var WorkflowFormRowBuilder = class {
       id: `${this.rowData.id}-${slotId}-${attribute}`,
       slotId,
       attribute,
-      label: _optionalChain([options, 'optionalAccess', _153 => _153.label]),
-      required: _optionalChain([options, 'optionalAccess', _154 => _154.required])
+      label: _optionalChain([options, 'optionalAccess', _148 => _148.label]),
+      required: _optionalChain([options, 'optionalAccess', _149 => _149.required])
     };
     this.rowData.fields.push(field);
     return this;
@@ -8304,7 +8048,7 @@ var WorkflowBuilder = class {
    * @param options - Slot configuration
    */
   slot(id, objectName, options) {
-    if (_optionalChain([this, 'access', _155 => _155.data, 'access', _156 => _156.slots, 'optionalAccess', _157 => _157.some, 'call', _158 => _158((s) => s.id === id)])) {
+    if (_optionalChain([this, 'access', _150 => _150.data, 'access', _151 => _151.slots, 'optionalAccess', _152 => _152.some, 'call', _153 => _153((s) => s.id === id)])) {
       throw new Error(`[WorkflowBuilder] Duplicate slot id: "${id}"`);
     }
     const slot = {
@@ -8315,7 +8059,7 @@ var WorkflowBuilder = class {
       color: options.color,
       icon: options.icon
     };
-    _optionalChain([this, 'access', _159 => _159.data, 'access', _160 => _160.slots, 'optionalAccess', _161 => _161.push, 'call', _162 => _162(slot)]);
+    _optionalChain([this, 'access', _154 => _154.data, 'access', _155 => _155.slots, 'optionalAccess', _156 => _156.push, 'call', _157 => _157(slot)]);
     return this;
   }
   // ============================================================================
@@ -8447,7 +8191,7 @@ var WorkflowBuilder = class {
     }
   }
   validateSlotReferences() {
-    const slotIds = _nullishCoalesce(_optionalChain([this, 'access', _163 => _163.data, 'access', _164 => _164.slots, 'optionalAccess', _165 => _165.reduce, 'call', _166 => _166((set, s) => set.add(s.id), /* @__PURE__ */ new Set())]), () => ( /* @__PURE__ */ new Set()));
+    const slotIds = _nullishCoalesce(_optionalChain([this, 'access', _158 => _158.data, 'access', _159 => _159.slots, 'optionalAccess', _160 => _160.reduce, 'call', _161 => _161((set, s) => set.add(s.id), /* @__PURE__ */ new Set())]), () => ( /* @__PURE__ */ new Set()));
     for (const node of Object.values(_nullishCoalesce(this.data.nodes, () => ( {})))) {
       if (node.type === "form") {
         const referencedSlots = /* @__PURE__ */ new Set();
@@ -8648,12 +8392,125 @@ function buildAuditChanges(oldValues, newValues, fieldsToCheck) {
   return changes;
 }
 
+// src/runtime/services/bilateral/bilateral-validation.service.ts
+var BilateralValidationService = class extends BaseService {
+  constructor(adapter, schemaService) {
+    super(adapter);
+    this.schemaService = schemaService;
+  }
+  /**
+   * Validate a bilateral relation configuration.
+   *
+   * Performs comprehensive checks:
+   * 1. Verifies target object exists
+   * 2. Verifies inverse attribute exists on target object
+   * 3. Verifies inverse attribute targets the source object
+   * 4. Detects invalid circular bilateral declarations
+   *
+   * @param sourceSchema - Schema containing the relation attribute
+   * @param sourceAttr - Relation attribute to validate
+   * @returns Validation result with errors if any
+   */
+  async validateBilateralRelation(sourceSchema, sourceAttr) {
+    const errors = [];
+    if (!(isBilateralRelation(sourceAttr) && sourceAttr.bilateral)) {
+      return { valid: true, errors: [] };
+    }
+    const { object: targetObjectName, attribute: inverseAttrName } = sourceAttr.bilateral;
+    let targetSchema = null;
+    try {
+      targetSchema = await this.schemaService.getObjectSchemaByName(targetObjectName);
+    } catch (e12) {
+      targetSchema = null;
+    }
+    if (!targetSchema) {
+      errors.push({
+        code: "INVERSE_ATTR_NOT_FOUND",
+        message: `Target object "${targetObjectName}" not found`,
+        context: {
+          sourceObject: sourceSchema.name,
+          sourceAttribute: sourceAttr.name,
+          targetObject: targetObjectName,
+          targetAttribute: inverseAttrName
+        }
+      });
+      return { valid: false, errors };
+    }
+    const inverseAttr = targetSchema.attributes.find(
+      (a) => a.name === inverseAttrName && a.type === "relation"
+    );
+    if (!inverseAttr) {
+      errors.push({
+        code: "INVERSE_ATTR_NOT_FOUND",
+        message: `Inverse attribute "${inverseAttrName}" not found on "${targetObjectName}"`,
+        context: {
+          sourceObject: sourceSchema.name,
+          sourceAttribute: sourceAttr.name,
+          targetObject: targetObjectName,
+          targetAttribute: inverseAttrName
+        }
+      });
+      return { valid: false, errors };
+    }
+    const inverseTargetsSource = inverseAttr.targets.some(
+      (target) => target.object === sourceSchema.name
+    );
+    if (!inverseTargetsSource) {
+      errors.push({
+        code: "INVERSE_TARGET_MISMATCH",
+        message: `Inverse attribute doesn't target source object`,
+        context: {
+          sourceObject: sourceSchema.name,
+          sourceAttribute: sourceAttr.name,
+          targetObject: targetObjectName,
+          targetAttribute: inverseAttrName
+        }
+      });
+    }
+    if (isBilateralRelation(inverseAttr)) {
+      const inverseBilateral = inverseAttr.bilateral;
+      if (inverseBilateral.object === sourceSchema.name && inverseBilateral.attribute !== sourceAttr.name) {
+        errors.push({
+          code: "CIRCULAR_BILATERAL",
+          message: "Both sides declare bilateral but point to different attributes",
+          context: {
+            sourceObject: sourceSchema.name,
+            sourceAttribute: sourceAttr.name,
+            targetObject: targetObjectName,
+            targetAttribute: inverseAttrName
+          }
+        });
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  }
+  /**
+   * Validate all bilateral relations in a schema.
+   *
+   * Iterates through all relation attributes and validates each bilateral configuration.
+   *
+   * @param schema - Object schema to validate
+   * @returns Combined validation result with all errors
+   */
+  async validateAllBilateralRelations(schema) {
+    const allErrors = [];
+    for (const attr of schema.attributes) {
+      if (attr.type === "relation" && isBilateralRelation(attr)) {
+        const result = await this.validateBilateralRelation(schema, attr);
+        allErrors.push(...result.errors);
+      }
+    }
+    return { valid: allErrors.length === 0, errors: allErrors };
+  }
+};
+
 // src/runtime/services/schema/object-schema.service.ts
 var ObjectSchemaService = class extends BaseService {
   constructor(adapter, nativeRegistry, options) {
     super(adapter);
     this.nativeRegistry = nativeRegistry;
-    this.auditService = _optionalChain([options, 'optionalAccess', _167 => _167.auditService]);
+    this.auditService = _optionalChain([options, 'optionalAccess', _162 => _162.auditService]);
+    this.bilateralValidationService = new BilateralValidationService(adapter, this);
   }
   /**
    * Create a new custom object.
@@ -8677,6 +8534,15 @@ var ObjectSchemaService = class extends BaseService {
       builder.attributes(definition.attributes);
     }
     const objectDef = builder.build();
+    const bilateralValidation = await this.bilateralValidationService.validateAllBilateralRelations(objectDef);
+    if (!bilateralValidation.valid) {
+      const errorMessages = bilateralValidation.errors.map((e) => `${e.code}: ${e.message}`).join("; ");
+      throw new SchemaError(
+        `Bilateral relation validation failed: ${errorMessages}`,
+        SchemaErrorCode.VALIDATION_FAILED,
+        { errors: bilateralValidation.errors }
+      );
+    }
     const existing = await this.adapter.objects.findByName(objectDef.name);
     if (existing) {
       throw new Error(`Object with name "${objectDef.name}" already exists`);
@@ -8766,6 +8632,28 @@ var ObjectSchemaService = class extends BaseService {
       );
     }
     const config = await this.validateAttributeInput(attribute);
+    if (attribute.type === "relation" && attribute.bilateral) {
+      const tempSchema = await this.getObjectSchema(objectId);
+      const tempAttr = {
+        ...attribute,
+        id: "temp-id",
+        // Temporary ID for validation
+        system: false,
+        config
+      };
+      const validation = await this.bilateralValidationService.validateBilateralRelation(
+        tempSchema,
+        tempAttr
+      );
+      if (!validation.valid) {
+        const errorMessages = validation.errors.map((e) => `${e.code}: ${e.message}`).join("; ");
+        throw new SchemaError(
+          `Bilateral relation validation failed: ${errorMessages}`,
+          SchemaErrorCode.VALIDATION_FAILED,
+          { errors: validation.errors }
+        );
+      }
+    }
     const dbAttr = await this.adapter.attributes.create({
       objectId,
       name: attribute.name,
@@ -8866,7 +8754,7 @@ var ObjectSchemaService = class extends BaseService {
           resourceType: "attribute",
           resourceId: attributeId,
           resourceLabel: updatedDbAttr.label,
-          objectName: _optionalChain([dbObject, 'optionalAccess', _168 => _168.name]),
+          objectName: _optionalChain([dbObject, 'optionalAccess', _163 => _163.name]),
           objectId: dbAttr.objectId,
           changes
         });
@@ -8899,7 +8787,7 @@ var ObjectSchemaService = class extends BaseService {
       );
     }
     const dbObject = await this.adapter.objects.findById(dbAttr.objectId);
-    if (_optionalChain([dbObject, 'optionalAccess', _169 => _169.labelExpression])) {
+    if (_optionalChain([dbObject, 'optionalAccess', _164 => _164.labelExpression])) {
       const usedAttributes = extractAttributeNames(dbObject.labelExpression);
       if (usedAttributes.includes(dbAttr.name)) {
         throw new AttributeInUseError(dbAttr.name, "labelExpression");
@@ -8915,7 +8803,7 @@ var ObjectSchemaService = class extends BaseService {
         resourceType: "attribute",
         resourceId: attributeId,
         resourceLabel: dbAttr.label,
-        objectName: _optionalChain([dbObject, 'optionalAccess', _170 => _170.name]),
+        objectName: _optionalChain([dbObject, 'optionalAccess', _165 => _165.name]),
         objectId: dbAttr.objectId
       });
     }
@@ -8930,9 +8818,9 @@ var ObjectSchemaService = class extends BaseService {
   async listAttributes(objectId, options) {
     const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
     let filtered = dbAttributes;
-    if (_optionalChain([options, 'optionalAccess', _171 => _171.systemOnly])) {
+    if (_optionalChain([options, 'optionalAccess', _166 => _166.systemOnly])) {
       filtered = dbAttributes.filter((attr) => attr.system);
-    } else if (_optionalChain([options, 'optionalAccess', _172 => _172.customOnly])) {
+    } else if (_optionalChain([options, 'optionalAccess', _167 => _167.customOnly])) {
       filtered = dbAttributes.filter((attr) => !attr.system);
     }
     return filtered.map((attr) => this.convertDBAttributeToAttribute(attr));
@@ -8968,14 +8856,14 @@ var ObjectSchemaService = class extends BaseService {
       pluralLabel: dbObject.pluralLabel,
       description: dbObject.description,
       labelExpression: dbObject.labelExpression,
-      icon: _optionalChain([dbObject, 'access', _173 => _173.metadata, 'optionalAccess', _174 => _174.icon])
+      icon: _optionalChain([dbObject, 'access', _168 => _168.metadata, 'optionalAccess', _169 => _169.icon])
     };
     let metadata = dbObject.metadata;
     if (updates.icon !== void 0 || updates.metadata !== void 0) {
       metadata = {
         ...dbObject.metadata,
         ...updates.metadata,
-        icon: _nullishCoalesce(updates.icon, () => ( _optionalChain([dbObject, 'access', _175 => _175.metadata, 'optionalAccess', _176 => _176.icon])))
+        icon: _nullishCoalesce(updates.icon, () => ( _optionalChain([dbObject, 'access', _170 => _170.metadata, 'optionalAccess', _171 => _171.icon])))
       };
     }
     const updatedDbObject = await this.adapter.objects.update(objectId, {
@@ -9190,19 +9078,71 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
   async buildObjectDefinition(dbObject) {
     const dbAttributes = await this.adapter.attributes.findByObjectId(dbObject.id);
     const baseDef = dbObject.system ? this.mergeNativeObject(dbObject, dbAttributes) : this.convertDBObjectToDefinition(dbObject, dbAttributes);
-    return this.withSystemAttributes(baseDef);
+    const enriched = await this.enrichBilateralProperties(baseDef);
+    return this.withSystemAttributes(enriched);
   }
   /**
-   * Append system attributes to an ObjectDefinition
-   * System attributes are always available on all records (createdAt, updatedAt, createdBy, lastUpdatedBy)
+   * Enrich bilateral relation attributes that don't own property definitions.
+   * Copies `properties` from the canonical side (the one with `.qualifyWith()`)
+   * and sets `storageOwner: false` so the storage layer knows direction.
+   *
+   * Uses direct DB lookups to avoid circular recursion through `getObjectSchema`.
    * @internal
    */
-  withSystemAttributes(def) {
+  async enrichBilateralProperties(def) {
+    const toEnrich = def.attributes.filter(
+      (attr) => attr.type === "relation" && !!attr.bilateral && !attr.properties
+    );
+    if (toEnrich.length === 0) return def;
+    const enrichedMap = /* @__PURE__ */ new Map();
+    for (const attr of toEnrich) {
+      const { bilateral } = attr;
+      if (!bilateral) continue;
+      const inverseObject = await this.adapter.objects.findByName(bilateral.object);
+      if (!inverseObject) continue;
+      const inverseDbAttrs = await this.adapter.attributes.findByObjectId(inverseObject.id);
+      const inverseDbAttr = inverseDbAttrs.find((a) => a.name === bilateral.attribute);
+      if (!inverseDbAttr) continue;
+      let properties = inverseDbAttr.config.properties;
+      if (!properties) {
+        const nativeObj = this.nativeRegistry.getByName(bilateral.object);
+        const nativeAttr = _optionalChain([nativeObj, 'optionalAccess', _172 => _172.attributes, 'access', _173 => _173.find, 'call', _174 => _174((a) => a.name === bilateral.attribute)]);
+        if (nativeAttr && "properties" in nativeAttr) {
+          properties = nativeAttr.properties;
+        }
+      }
+      if (properties) {
+        enrichedMap.set(attr.name, {
+          properties,
+          bilateral: { ...bilateral, storageOwner: false }
+        });
+      }
+    }
+    if (enrichedMap.size === 0) return def;
     return {
       ...def,
-      attributes: [...def.attributes, ...getSystemAttributeList()]
-    };
-  }
+      attributes: def.attributes.map((attr) => {
+        const enrichment = enrichedMap.get(attr.name);
+        if (!enrichment) return attr;
+        return {
+          ...attr,
+          properties: enrichment.properties,
+          bilateral: enrichment.bilateral
+        };
+      })
+    };
+  }
+  /**
+   * Append system attributes to an ObjectDefinition
+   * System attributes are always available on all records (createdAt, updatedAt, createdBy, lastUpdatedBy)
+   * @internal
+   */
+  withSystemAttributes(def) {
+    return {
+      ...def,
+      attributes: [...def.attributes, ...getSystemAttributeList()]
+    };
+  }
   /**
    * Merge native object from registry with custom attributes from DB
    * @internal
@@ -9255,7 +9195,7 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
       label: dbObject.label,
       pluralLabel: dbObject.pluralLabel,
       description: dbObject.description,
-      icon: _optionalChain([dbObject, 'access', _177 => _177.metadata, 'optionalAccess', _178 => _178.icon]),
+      icon: _optionalChain([dbObject, 'access', _175 => _175.metadata, 'optionalAccess', _176 => _176.icon]),
       labelExpression: dbObject.labelExpression,
       attributes,
       system: dbObject.system,
@@ -9355,7 +9295,7 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
       const hasRelationToTarget = attrs.some((attr) => {
         if (attr.type !== "relation") return false;
         const config = attr.config;
-        return _nullishCoalesce(_optionalChain([config, 'optionalAccess', _179 => _179.targets, 'optionalAccess', _180 => _180.some, 'call', _181 => _181((t) => t.object === targetObjectName)]), () => ( false));
+        return _nullishCoalesce(_optionalChain([config, 'optionalAccess', _177 => _177.targets, 'optionalAccess', _178 => _178.some, 'call', _179 => _179((t) => t.object === targetObjectName)]), () => ( false));
       });
       if (hasRelationToTarget) {
         referencing.push(obj.name);
@@ -9433,7 +9373,7 @@ Native objects must have system=true. Did you forget to call .system() in your b
       const existing = this.objects.get(object2.name);
       throw new Error(
         `[NativeObjectRegistry] Duplicate object name "${object2.name}":
-  - Existing: "${_optionalChain([existing, 'optionalAccess', _182 => _182.label])}" (id: ${_optionalChain([existing, 'optionalAccess', _183 => _183.id])})
+  - Existing: "${_optionalChain([existing, 'optionalAccess', _180 => _180.label])}" (id: ${_optionalChain([existing, 'optionalAccess', _181 => _181.id])})
   - New: "${object2.label}" (id: ${object2.id})
 Please use unique names for each native object.`
       );
@@ -9550,7 +9490,7 @@ var AuditService = class extends BaseService {
     this.isFlushing = false;
     /** Pending flush promise to allow waiting on concurrent flush */
     this.flushPromise = null;
-    if (_optionalChain([options, 'optionalAccess', _184 => _184.async]) && options.flushIntervalMs) {
+    if (_optionalChain([options, 'optionalAccess', _182 => _182.async]) && options.flushIntervalMs) {
       this.startFlushTimer();
     }
   }
@@ -9747,7 +9687,7 @@ var AuditService = class extends BaseService {
     if (!this.adapter.audit) {
       return;
     }
-    if (_optionalChain([this, 'access', _185 => _185.options, 'optionalAccess', _186 => _186.async])) {
+    if (_optionalChain([this, 'access', _183 => _183.options, 'optionalAccess', _184 => _184.async])) {
       this.buffer.push(entry);
       const batchSize = _nullishCoalesce(this.options.batchSize, () => ( 10));
       if (this.buffer.length >= batchSize) {
@@ -9761,7 +9701,7 @@ var AuditService = class extends BaseService {
    * Start the flush timer for async mode
    */
   startFlushTimer() {
-    const intervalMs = _nullishCoalesce(_optionalChain([this, 'access', _187 => _187.options, 'optionalAccess', _188 => _188.flushIntervalMs]), () => ( 1e3));
+    const intervalMs = _nullishCoalesce(_optionalChain([this, 'access', _185 => _185.options, 'optionalAccess', _186 => _186.flushIntervalMs]), () => ( 1e3));
     this.flushTimer = setInterval(() => {
       this.flush().catch(() => {
       });
@@ -9785,6 +9725,303 @@ var AuditService = class extends BaseService {
   }
 };
 
+// src/runtime/services/bilateral/bilateral-sync.service.ts
+var browserStub4 = {
+  getStore: () => void 0,
+  run: (_store, callback) => callback()
+};
+var AsyncLocalStorageClass4 = null;
+if (typeof process !== "undefined" && _optionalChain([process, 'access', _187 => _187.versions, 'optionalAccess', _188 => _188.node])) {
+  try {
+    if (typeof _chunk3RG5ZIWIjs.__require !== "undefined") {
+      const asyncHooks = _chunk3RG5ZIWIjs.__require.call(void 0, "async_hooks");
+      AsyncLocalStorageClass4 = asyncHooks.AsyncLocalStorage;
+    }
+  } catch (e13) {
+    try {
+      const dynamicRequire = new Function(
+        "m",
+        'return typeof require!=="undefined"?require(m):null'
+      );
+      const asyncHooks = dynamicRequire("node:async_hooks");
+      if (asyncHooks) {
+        AsyncLocalStorageClass4 = asyncHooks.AsyncLocalStorage;
+      }
+    } catch (e14) {
+    }
+  }
+}
+var bilateralSyncContext = null;
+function getSyncContext() {
+  if (bilateralSyncContext !== null) {
+    return bilateralSyncContext;
+  }
+  if (AsyncLocalStorageClass4) {
+    bilateralSyncContext = new AsyncLocalStorageClass4();
+    return bilateralSyncContext;
+  }
+  bilateralSyncContext = browserStub4;
+  return bilateralSyncContext;
+}
+var BilateralSyncService = class extends BaseService {
+  constructor(adapter, schemaService, relationPropertiesService) {
+    super(adapter);
+    this.schemaService = schemaService;
+    this.relationPropertiesService = relationPropertiesService;
+  }
+  // ============================================================================
+  // PUBLIC API
+  // ============================================================================
+  /**
+   * Synchronize a bilateral relation after modification.
+   *
+   * @param sourceSchema - Schema of the object containing the relation
+   * @param sourceRecordId - ID of the record being modified
+   * @param attributeName - Name of the relation attribute
+   * @param newValue - New value (ID, array of IDs, or hybrid format with properties)
+   * @param oldValue - Old value (ID, array of IDs, or hybrid format with properties)
+   */
+  async syncBilateralRelation(sourceSchema, sourceRecordId, attributeName, newValue, oldValue) {
+    const attribute = sourceSchema.attributes.find(
+      (a) => a.name === attributeName && a.type === "relation"
+    );
+    if (!(attribute && isBilateralRelation(attribute))) {
+      return;
+    }
+    const ctx = getSyncContext().getStore();
+    const syncKey = `${sourceSchema.name}:${sourceRecordId}:${attributeName}`;
+    if (_optionalChain([ctx, 'optionalAccess', _189 => _189.syncing, 'access', _190 => _190.has, 'call', _191 => _191(syncKey)])) {
+      return;
+    }
+    await this.runWithSyncContext(syncKey, async () => {
+      await this.performBilateralSync(sourceSchema, sourceRecordId, attribute, newValue, oldValue);
+    });
+  }
+  // ============================================================================
+  // PRIVATE METHODS
+  // ============================================================================
+  /**
+   * Perform the bidirectional synchronization.
+   * @private
+   */
+  async performBilateralSync(sourceSchema, sourceRecordId, sourceAttr, newValue, oldValue) {
+    const bilateral = sourceAttr.bilateral;
+    const targetSchema = await this.schemaService.getObjectSchemaByName(bilateral.object);
+    if (!targetSchema) {
+      throw new Error(`Target object "${bilateral.object}" not found`);
+    }
+    const inverseAttr = targetSchema.attributes.find(
+      (a) => a.name === bilateral.attribute && a.type === "relation"
+    );
+    if (!inverseAttr) {
+      throw new Error(
+        `Inverse attribute "${bilateral.attribute}" not found on "${bilateral.object}"`
+      );
+    }
+    const newData = this.extractRelationData(newValue);
+    const oldData = this.extractRelationData(oldValue);
+    const addedIds = newData.ids.filter((id) => !oldData.ids.includes(id));
+    const removedIds = oldData.ids.filter((id) => !newData.ids.includes(id));
+    const commonIds = newData.ids.filter((id) => oldData.ids.includes(id));
+    await Promise.all([
+      // Add new relations
+      ...addedIds.map(
+        (targetId) => this.addInverseRelation(
+          targetId,
+          inverseAttr,
+          sourceRecordId,
+          sourceSchema.name,
+          sourceAttr.name,
+          newData.properties.get(targetId)
+        )
+      ),
+      // Remove deleted relations
+      ...removedIds.map(
+        (targetId) => this.removeInverseRelation(targetId, inverseAttr, sourceRecordId)
+      ),
+      // Update properties for common IDs
+      ...commonIds.map(
+        (targetId) => this.updateInverseRelationProperties(
+          targetId,
+          inverseAttr,
+          sourceRecordId,
+          sourceSchema.name,
+          sourceAttr.name,
+          newData.properties.get(targetId),
+          oldData.properties.get(targetId)
+        )
+      )
+    ]);
+  }
+  /**
+   * Extract IDs and properties from hybrid relation value.
+   * @private
+   */
+  extractRelationData(value) {
+    const ids = [];
+    const properties = /* @__PURE__ */ new Map();
+    if (value === null || value === void 0) {
+      return { ids, properties };
+    }
+    if (typeof value === "string") {
+      ids.push(value);
+      return { ids, properties };
+    }
+    if (!Array.isArray(value) && typeof value === "object" && "id" in value) {
+      ids.push(value.id);
+      if (value.props) {
+        properties.set(value.id, value.props);
+      }
+      return { ids, properties };
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (typeof item === "string") {
+          ids.push(item);
+        } else if (typeof item === "object" && item !== null && "id" in item) {
+          ids.push(item.id);
+          if (item.props) {
+            properties.set(item.id, item.props);
+          }
+        }
+      }
+    }
+    return { ids, properties };
+  }
+  /**
+   * Add an ID to an inverse relation (with properties).
+   * @private
+   */
+  async addInverseRelation(targetRecordId, inverseAttr, sourceRecordId, sourceObject, sourceAttribute, properties) {
+    const targetRecord = await this.adapter.objectRecords.findById(targetRecordId);
+    if (!targetRecord) {
+      return;
+    }
+    const currentValue = targetRecord.values[inverseAttr.name];
+    let newValue;
+    if (inverseAttr.cardinality === "one") {
+      newValue = sourceRecordId;
+    } else {
+      const currentArray = this.normalizeToArray(currentValue);
+      if (currentArray.includes(sourceRecordId)) {
+        return;
+      }
+      newValue = [...currentArray, sourceRecordId];
+    }
+    await this.adapter.objectRecords.update(targetRecordId, {
+      [inverseAttr.name]: newValue
+    });
+    await this.invalidateTargetRecordCaches(targetRecordId, targetRecord.objectId);
+    if (properties && Object.keys(properties).length > 0 && this.adapter.relationAttributes) {
+      const sourceSchema = await this.schemaService.getObjectSchemaByName(sourceObject);
+      if (sourceSchema) {
+        await this.relationPropertiesService.syncRelationProperties(
+          sourceSchema,
+          sourceRecordId,
+          sourceAttribute,
+          [{ id: targetRecordId, props: properties }],
+          this.adapter
+        );
+      }
+    }
+  }
+  /**
+   * Update properties of an existing inverse relation.
+   * @private
+   */
+  async updateInverseRelationProperties(targetRecordId, _inverseAttr, sourceRecordId, sourceObject, sourceAttribute, newProperties, oldProperties) {
+    if (JSON.stringify(newProperties) === JSON.stringify(oldProperties)) {
+      return;
+    }
+    if (!this.adapter.relationAttributes) {
+      return;
+    }
+    const sourceSchema = await this.schemaService.getObjectSchemaByName(sourceObject);
+    if (!sourceSchema) {
+      return;
+    }
+    if (newProperties && Object.keys(newProperties).length > 0) {
+      await this.relationPropertiesService.syncRelationProperties(
+        sourceSchema,
+        sourceRecordId,
+        sourceAttribute,
+        [{ id: targetRecordId, props: newProperties }],
+        this.adapter
+      );
+    } else {
+      await this.adapter.relationAttributes.deleteBySource(
+        sourceObject,
+        sourceRecordId,
+        sourceAttribute
+      );
+    }
+  }
+  /**
+   * Remove an ID from an inverse relation.
+   * @private
+   */
+  async removeInverseRelation(targetRecordId, inverseAttr, sourceRecordId) {
+    const targetRecord = await this.adapter.objectRecords.findById(targetRecordId);
+    if (!targetRecord) {
+      return;
+    }
+    const currentValue = targetRecord.values[inverseAttr.name];
+    let newValue;
+    if (inverseAttr.cardinality === "one") {
+      if (currentValue === sourceRecordId) {
+        newValue = null;
+      } else {
+        return;
+      }
+    } else {
+      const currentArray = this.normalizeToArray(currentValue);
+      newValue = currentArray.filter((id) => id !== sourceRecordId);
+      if (newValue.length === currentArray.length) {
+        return;
+      }
+    }
+    await this.adapter.objectRecords.update(targetRecordId, {
+      [inverseAttr.name]: newValue
+    });
+    await this.invalidateTargetRecordCaches(targetRecordId, targetRecord.objectId);
+  }
+  /**
+   * Normalize a relation value to an array of IDs.
+   * @private
+   */
+  normalizeToArray(value) {
+    if (value === null || value === void 0) return [];
+    if (typeof value === "string") return [value];
+    if (Array.isArray(value)) return value;
+    return [];
+  }
+  /**
+   * Invalidate caches for a target record after bilateral update.
+   * Mirrors RecordService.invalidateRecordCaches to ensure consistency.
+   * @private
+   */
+  async invalidateTargetRecordCaches(recordId, objectId) {
+    await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
+    await this.invalidateLists("allRecordLists", objectId);
+    await this.invalidateLists("allSearchResults", objectId);
+    await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+  }
+  /**
+   * Execute a function with sync context.
+   * @private
+   */
+  async runWithSyncContext(syncKey, fn) {
+    const storage = getSyncContext();
+    const existingCtx = storage.getStore();
+    const ctx = {
+      syncing: new Set(_nullishCoalesce(_optionalChain([existingCtx, 'optionalAccess', _192 => _192.syncing]), () => ( [])))
+    };
+    ctx.syncing.add(syncKey);
+    return await storage.run(ctx, fn);
+  }
+};
+
 // src/runtime/services/user/user.service.ts
 var UserService = class extends BaseService {
   constructor(adapter) {
@@ -9869,7 +10106,7 @@ var UserService = class extends BaseService {
       if (roleErrors.length > 0) {
         errors.push({
           attribute: attrName,
-          message: `Users do not have required role for ${attr.label}. Allowed roles: ${_optionalChain([attr, 'access', _189 => _189.allowedRoles, 'optionalAccess', _190 => _190.join, 'call', _191 => _191(", ")])}`,
+          message: `Users do not have required role for ${attr.label}. Allowed roles: ${_optionalChain([attr, 'access', _193 => _193.allowedRoles, 'optionalAccess', _194 => _194.join, 'call', _195 => _195(", ")])}`,
           invalidIds: roleErrors
         });
       }
@@ -10185,122 +10422,473 @@ async function recalculateParentRollups(record, schema, ctx) {
   }
 }
 
-// src/runtime/services/record/query.service.ts
-var RecordQueryService = class extends BaseService {
-  constructor(adapter, schemaService, options) {
+// src/runtime/services/record/relation-properties.service.ts
+
+var RelationPropertiesService = class extends BaseService {
+  constructor(adapter) {
     super(adapter);
-    this.schemaService = schemaService;
-    this.options = options;
-    this.policyRegistry = _optionalChain([options, 'optionalAccess', _192 => _192.policyRegistry]) === null ? null : _nullishCoalesce(_optionalChain([options, 'optionalAccess', _193 => _193.policyRegistry]), () => ( defaultPolicyRegistry));
   }
   // ============================================================================
-  // LIST
+  // PUBLIC API
   // ============================================================================
   /**
-   * List records for an object with pagination, permissions, and policy filtering.
+   * Get relation properties for a given attribute.
    *
-   * @param objectId - Object UUID
-   * @param options - Query options (pagination, filters, etc.)
-   * @returns Records and total count
+   * Supports bidirectional relations: searches for properties in both directions
+   * (forward: from_object/from_id → to_id, and inverse: to_id → from_id).
+   *
+   * This ensures that qualified properties are SHARED between both directions
+   * of a bilateral relation, as they are stored in a single row in relation_attributes.
+   *
+   * @param objectName - Source object name
+   * @param recordId - Source record ID
+   * @param attributeName - Relation attribute name
+   * @param targetIds - Array of target record IDs
+   * @returns Map of target ID → properties
    *
    * @example
    * ```typescript
-   * const { records, total } = await queryService.listRecords(objectId, {
-   *   limit: 20,
-   *   offset: 0,
-   *   filters: { status: "active" },
-   * });
+   * // Properties stored as: contacts/A/companies → X with { role: "CEO" }
+   *
+   * // Read from Contact A → Company X
+   * const propsFromContact = await service.getRelationProperties(
+   *   "contacts", "A", "companies", ["X"]
+   * );
+   * // → Map { "X" => { role: "CEO" } }
+   *
+   * // Read from Company X → Contact A (inverse)
+   * const propsFromCompany = await service.getRelationProperties(
+   *   "companies", "X", "contacts", ["A"]
+   * );
+   * // → Map { "A" => { role: "CEO" } } (same properties!)
    * ```
    */
-  async listRecords(objectId, options) {
-    const schema = await this.schemaService.getObjectSchema(objectId);
-    return this.cachedList(
-      "recordList",
-      objectId,
-      { ...options, _userId: this.userId },
-      () => this.executeListQuery(schema, objectId, options)
-    );
-  }
-  /**
-   * List records using a pre-fetched schema.
-   * Useful when the caller already has the schema to avoid redundant lookups.
-   */
-  async listRecordsWithSchema(schema, options) {
-    if (!schema.id) {
-      throw new Error("Schema must have an ID to list records");
+  async getRelationProperties(objectName, recordId, attributeName, targetIds) {
+    const properties = /* @__PURE__ */ new Map();
+    if (!this.adapter.relationAttributes) {
+      return properties;
     }
-    const objectId = schema.id;
-    return this.cachedList(
-      "recordList",
-      objectId,
-      { ...options, _userId: this.userId },
-      () => this.executeListQuery(schema, objectId, options)
+    const forwardProps = await this.adapter.relationAttributes.findBySource(
+      objectName,
+      recordId,
+      attributeName
     );
+    for (const prop of forwardProps) {
+      if (targetIds.includes(prop.toId)) {
+        properties.set(prop.toId, prop.properties);
+      }
+    }
+    const inverseProps = await this.adapter.relationAttributes.findByTarget(recordId);
+    for (const prop of inverseProps) {
+      if (targetIds.includes(prop.fromId) && !properties.has(prop.fromId)) {
+        properties.set(prop.fromId, prop.properties);
+      }
+    }
+    return properties;
   }
   /**
-   * Internal list query execution
+   * Batch enrich records with qualified relation properties.
+   *
+   * Detects qualified attributes in the schema and fetches their properties
+   * using batch queries (1 query per qualified attribute, not per record).
+   * Returns records with values in hybrid format `{ id, props }`.
+   *
+   * For bilateral relations, also checks the inverse direction.
+   *
+   * @param records - Records to enrich
+   * @param schema - Object schema
+   * @returns Records with relation values enriched with properties
    */
-  async executeListQuery(schema, objectId, options) {
-    if (_optionalChain([this, 'access', _194 => _194.options, 'optionalAccess', _195 => _195.permissionService]) && this.userId) {
-      await checkPermission(this.options.permissionService, this.userId, schema.name, "read");
-    }
-    const policy = _optionalChain([options, 'optionalAccess', _196 => _196.skipPolicyFilter]) ? void 0 : getPolicy(this.policyRegistry, this.userId, schema.name);
-    let effectiveOptions = options;
-    if (_optionalChain([policy, 'optionalAccess', _197 => _197.applyListFilter]) && this.userId) {
-      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
-      effectiveOptions = policy.applyListFilter(ctx, options);
-    }
-    const result = await runWithSchemaContext(
-      [schema],
-      () => this.adapter.objectRecords.list(objectId, effectiveOptions)
+  async enrichRecordsBatch(records, schema) {
+    if (!this.adapter.relationAttributes) return records;
+    if (records.length === 0) return records;
+    const qualifiedAttrs = schema.attributes.filter(
+      (a) => a.type === "relation" && (!!a.properties || !!a.bilateral)
     );
-    let filteredRecords = result.records;
-    let effectiveTotal = result.total;
-    if (_optionalChain([policy, 'optionalAccess', _198 => _198.canAccessRecord]) && this.userId) {
-      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
-      const requestedLimit = _nullishCoalesce(_optionalChain([effectiveOptions, 'optionalAccess', _199 => _199.limit]), () => ( 20));
-      const requestedOffset = _nullishCoalesce(_optionalChain([effectiveOptions, 'optionalAccess', _200 => _200.offset]), () => ( 0));
-      const overfetchMultiplier = 5;
-      const batchSize = requestedLimit * overfetchMultiplier;
-      const maxScanRecords = 1e4;
-      const collected = [];
-      let dbOffset = 0;
-      let totalScanned = 0;
-      let exhausted = false;
-      const target = requestedOffset + requestedLimit;
-      while (collected.length < target && totalScanned < maxScanRecords) {
-        const batch = await runWithSchemaContext(
-          [schema],
-          () => this.adapter.objectRecords.list(objectId, {
-            ...effectiveOptions,
-            limit: batchSize,
-            offset: dbOffset
-          })
+    if (qualifiedAttrs.length === 0) return records;
+    const recordIds = records.map((r) => r.id);
+    const relationAttrsRepo = this.adapter.relationAttributes;
+    await Promise.all(
+      qualifiedAttrs.map(async (attr) => {
+        const forwardRows = await relationAttrsRepo.findBySourceBatch(
+          schema.name,
+          recordIds,
+          attr.name
         );
-        if (batch.records.length === 0) {
-          exhausted = true;
-          break;
+        const inverseRows = attr.bilateral ? await relationAttrsRepo.findByTargetBatch(recordIds) : [];
+        const byRecord = /* @__PURE__ */ new Map();
+        for (const row of forwardRows) {
+          let recordMap = byRecord.get(row.fromId);
+          if (!recordMap) {
+            recordMap = /* @__PURE__ */ new Map();
+            byRecord.set(row.fromId, recordMap);
+          }
+          recordMap.set(row.toId, row.properties);
         }
-        const filtered = batch.records.filter((record) => _optionalChain([policy, 'access', _201 => _201.canAccessRecord, 'optionalCall', _202 => _202(ctx, record)]));
-        collected.push(...filtered);
-        dbOffset += batch.records.length;
-        totalScanned += batch.records.length;
-        if (batch.records.length < batchSize) {
-          exhausted = true;
-          break;
+        for (const row of inverseRows) {
+          let recordMap = byRecord.get(row.toId);
+          if (!recordMap) {
+            recordMap = /* @__PURE__ */ new Map();
+            byRecord.set(row.toId, recordMap);
+          }
+          if (!recordMap.has(row.fromId)) {
+            recordMap.set(row.fromId, row.properties);
+          }
         }
-      }
-      effectiveTotal = exhausted ? collected.length : Math.max(collected.length, result.total);
-      filteredRecords = collected.slice(requestedOffset, requestedOffset + requestedLimit);
-    }
-    if (_optionalChain([options, 'optionalAccess', _203 => _203.include]) && options.include.length > 0) {
-      filteredRecords = await this.includeRelationsWithProperties(
-        filteredRecords,
-        schema,
-        options.include
-      );
+        for (const record of records) {
+          const propsForRecord = byRecord.get(record.id);
+          if (!propsForRecord) continue;
+          const value = record.values[attr.name];
+          if (Array.isArray(value)) {
+            record.values = {
+              ...record.values,
+              [attr.name]: value.map((id) => {
+                const props = propsForRecord.get(id);
+                return props ? { id, props } : id;
+              })
+            };
+          } else if (typeof value === "string") {
+            const props = propsForRecord.get(value);
+            if (props) {
+              record.values = {
+                ...record.values,
+                [attr.name]: { id: value, props }
+              };
+            }
+          }
+        }
+      })
+    );
+    return records;
+  }
+  /**
+   * Normalize relation values for storage in object_records table.
+   *
+   * Extracts IDs from hybrid format ({ id, props }) and returns legacy format (string[] or string).
+   * This ensures object_records.values only contains IDs, while properties are in relation_attributes.
+   *
+   * @param schema - Object schema
+   * @param data - Record data with hybrid relation values
+   * @returns Data with relation values normalized to ID-only format
+   */
+  normalizeRelationValuesForStorage(schema, data) {
+    const normalized = { ...data };
+    for (const attr of schema.attributes) {
+      if (attr.type !== "relation") {
+        continue;
+      }
+      const value = data[attr.name];
+      if (value === null || value === void 0) {
+        continue;
+      }
+      if (attr.cardinality === "many" && Array.isArray(value)) {
+        normalized[attr.name] = value.map((item) => {
+          if (typeof item === "string") return item;
+          if (typeof item === "object" && item !== null && "id" in item) {
+            return item.id;
+          }
+          return item;
+        });
+      } else if (typeof value === "object" && value !== null && "id" in value) {
+        normalized[attr.name] = value.id;
+      }
+    }
+    return normalized;
+  }
+  /**
+   * Synchronize relation properties for a given attribute.
+   *
+   * Handles:
+   * - Format normalization (legacy → new)
+   * - Validation of properties
+   * - Upsert for present IDs
+   * - Delete for absent IDs
+   *
+   * @param schema - Object schema
+   * @param recordId - Source record ID
+   * @param attributeName - Relation attribute name
+   * @param relationValue - Relation value (hybrid format)
+   * @param adapter - Database adapter
+   */
+  async syncRelationProperties(schema, recordId, attributeName, relationValue, adapter) {
+    const attribute = schema.attributes.find((a) => a.name === attributeName);
+    if (!attribute || attribute.type !== "relation") {
+      return;
+    }
+    const normalized = this.normalizeRelationValue(relationValue);
+    const propertySchema = this.getPropertySchema(attribute);
+    const hasPropsInInput = normalized.some((item) => item.props !== void 0);
+    const hasSchema = Boolean(propertySchema);
+    const canSync = hasSchema || hasPropsInInput;
+    if (!canSync) {
+      return;
+    }
+    if (propertySchema) {
+      for (const item of normalized) {
+        if (item.props && Object.keys(item.props).length > 0) {
+          this.validateProperties(propertySchema, item.props);
+        }
+      }
+    }
+    const shouldStoreAsInverse = _optionalChain([attribute, 'access', _196 => _196.bilateral, 'optionalAccess', _197 => _197.storageOwner]) === false;
+    let storageFromObject = schema.name;
+    let storageFromAttribute = attributeName;
+    if (shouldStoreAsInverse && attribute.bilateral) {
+      storageFromObject = attribute.bilateral.object;
+      storageFromAttribute = attribute.bilateral.attribute;
+    }
+    let existing;
+    if (adapter.relationAttributes) {
+      if (shouldStoreAsInverse) {
+        const results = await Promise.all(
+          normalized.map(
+            (item) => _optionalChain([adapter, 'access', _198 => _198.relationAttributes, 'optionalAccess', _199 => _199.findBySource, 'call', _200 => _200(
+              storageFromObject,
+              item.id,
+              storageFromAttribute
+            )])
+          )
+        );
+        existing = results.filter((r) => r !== void 0).flat().filter((r) => r.toId === recordId);
+      } else {
+        existing = await adapter.relationAttributes.findBySource(
+          schema.name,
+          recordId,
+          attributeName
+        );
+      }
+    }
+    const hasChanges = existing && existing.length > 0;
+    const toUpsert = normalized.filter((item) => {
+      return item.props !== void 0 && Object.keys(item.props).length > 0;
+    });
+    if (!adapter.relationAttributes) {
+      return;
+    }
+    if (hasChanges && existing) {
+      if (shouldStoreAsInverse) {
+        for (const item of normalized) {
+          await adapter.relationAttributes.deleteBySourceAndTarget(
+            storageFromObject,
+            item.id,
+            storageFromAttribute,
+            recordId
+          );
+        }
+      } else {
+        await adapter.relationAttributes.deleteBySource(schema.name, recordId, attributeName);
+      }
+    }
+    if (toUpsert.length > 0) {
+      const inputs = toUpsert.map((item) => {
+        if (shouldStoreAsInverse) {
+          return {
+            fromObject: storageFromObject,
+            fromId: item.id,
+            fromAttribute: storageFromAttribute,
+            toId: recordId,
+            properties: _nullishCoalesce(item.props, () => ( {})),
+            updatedBy: _nullishCoalesce(this.userId, () => ( void 0)),
+            createdBy: _nullishCoalesce(this.userId, () => ( void 0))
+          };
+        }
+        return {
+          fromObject: schema.name,
+          fromId: recordId,
+          fromAttribute: attributeName,
+          toId: item.id,
+          properties: _nullishCoalesce(item.props, () => ( {})),
+          updatedBy: _nullishCoalesce(this.userId, () => ( void 0)),
+          createdBy: _nullishCoalesce(this.userId, () => ( void 0))
+        };
+      });
+      await adapter.relationAttributes.upsertBatch(inputs);
+    }
+  }
+  /**
+   * Validate relation properties against PropertySchema.
+   *
+   * Uses Zod for runtime validation based on PropertyAttribute types.
+   *
+   * @param propertySchema - Schema defining allowed properties
+   * @param properties - Properties to validate
+   * @throws {z.ZodError} if validation fails
+   */
+  validateProperties(propertySchema, properties) {
+    const schema = this.buildZodSchema(propertySchema);
+    schema.parse(properties);
+  }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
+  /**
+   * Get PropertySchema for a relation attribute.
+   *
+   * For bilateral relations without .qualifyWith(), returns undefined.
+   * Properties will be stored/retrieved but not validated on the inverse side.
+   */
+  getPropertySchema(attribute) {
+    return attribute.properties;
+  }
+  /**
+   * Normalize relation value to unified internal format.
+   *
+   * Converts:
+   * - string[] → Array<{ id, props?: undefined }>
+   * - string → [{ id, props?: undefined }]
+   * - null → []
+   * - Array<{ id, props }> → Array<{ id, props }> (passthrough)
+   * - { id, props } → [{ id, props }] (single to array)
+   */
+  normalizeRelationValue(value) {
+    if (value === null || value === void 0) {
+      return [];
+    }
+    if (typeof value === "string") {
+      return [{ id: value }];
+    }
+    if (!Array.isArray(value) && typeof value === "object" && "id" in value) {
+      return [value];
+    }
+    if (Array.isArray(value)) {
+      return value.map((item) => {
+        if (typeof item === "string") {
+          return { id: item };
+        }
+        return item;
+      });
     }
-    if (!_optionalChain([options, 'optionalAccess', _204 => _204.skipFormulas])) {
+    return [];
+  }
+  /**
+   * Build Zod schema from PropertySchema definition.
+   *
+   * Reuses createFormAttributeValidator() to avoid code duplication with validators.ts.
+   * This validator handles null/undefined values correctly for optional fields.
+   */
+  buildZodSchema(propertySchema) {
+    const shape = {};
+    for (const def of propertySchema.definitions) {
+      shape[def.name] = _chunkU4AB53AMjs.createFormAttributeValidator.call(void 0, def);
+    }
+    return _zod.z.object(shape);
+  }
+};
+
+// src/runtime/services/record/query.service.ts
+var RecordQueryService = class extends BaseService {
+  constructor(adapter, schemaService, options) {
+    super(adapter);
+    this.schemaService = schemaService;
+    this.options = options;
+    this.policyRegistry = _optionalChain([options, 'optionalAccess', _201 => _201.policyRegistry]) === null ? null : _nullishCoalesce(_optionalChain([options, 'optionalAccess', _202 => _202.policyRegistry]), () => ( defaultPolicyRegistry));
+    this.relationPropertiesService = new RelationPropertiesService(adapter);
+  }
+  // ============================================================================
+  // LIST
+  // ============================================================================
+  /**
+   * List records for an object with pagination, permissions, and policy filtering.
+   *
+   * @param objectId - Object UUID
+   * @param options - Query options (pagination, filters, etc.)
+   * @returns Records and total count
+   *
+   * @example
+   * ```typescript
+   * const { records, total } = await queryService.listRecords(objectId, {
+   *   limit: 20,
+   *   offset: 0,
+   *   filters: { status: "active" },
+   * });
+   * ```
+   */
+  async listRecords(objectId, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
+    return this.cachedList(
+      "recordList",
+      objectId,
+      { ...options, _userId: this.userId },
+      () => this.executeListQuery(schema, objectId, options)
+    );
+  }
+  /**
+   * List records using a pre-fetched schema.
+   * Useful when the caller already has the schema to avoid redundant lookups.
+   */
+  async listRecordsWithSchema(schema, options) {
+    if (!schema.id) {
+      throw new Error("Schema must have an ID to list records");
+    }
+    const objectId = schema.id;
+    return this.cachedList(
+      "recordList",
+      objectId,
+      { ...options, _userId: this.userId },
+      () => this.executeListQuery(schema, objectId, options)
+    );
+  }
+  /**
+   * Internal list query execution
+   */
+  async executeListQuery(schema, objectId, options) {
+    if (_optionalChain([this, 'access', _203 => _203.options, 'optionalAccess', _204 => _204.permissionService]) && this.userId) {
+      await checkPermission(this.options.permissionService, this.userId, schema.name, "read");
+    }
+    const policy = _optionalChain([options, 'optionalAccess', _205 => _205.skipPolicyFilter]) ? void 0 : getPolicy(this.policyRegistry, this.userId, schema.name);
+    let effectiveOptions = options;
+    if (_optionalChain([policy, 'optionalAccess', _206 => _206.applyListFilter]) && this.userId) {
+      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
+      effectiveOptions = policy.applyListFilter(ctx, options);
+    }
+    const result = await runWithSchemaContext(
+      [schema],
+      () => this.adapter.objectRecords.list(objectId, effectiveOptions)
+    );
+    let filteredRecords = result.records;
+    let effectiveTotal = result.total;
+    if (_optionalChain([policy, 'optionalAccess', _207 => _207.canAccessRecord]) && this.userId) {
+      const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
+      const requestedLimit = _nullishCoalesce(_optionalChain([effectiveOptions, 'optionalAccess', _208 => _208.limit]), () => ( 20));
+      const requestedOffset = _nullishCoalesce(_optionalChain([effectiveOptions, 'optionalAccess', _209 => _209.offset]), () => ( 0));
+      const overfetchMultiplier = 5;
+      const batchSize = requestedLimit * overfetchMultiplier;
+      const maxScanRecords = 1e4;
+      const collected = [];
+      let dbOffset = 0;
+      let totalScanned = 0;
+      let exhausted = false;
+      const target = requestedOffset + requestedLimit;
+      while (collected.length < target && totalScanned < maxScanRecords) {
+        const batch = await runWithSchemaContext(
+          [schema],
+          () => this.adapter.objectRecords.list(objectId, {
+            ...effectiveOptions,
+            limit: batchSize,
+            offset: dbOffset
+          })
+        );
+        if (batch.records.length === 0) {
+          exhausted = true;
+          break;
+        }
+        const filtered = batch.records.filter((record) => _optionalChain([policy, 'access', _210 => _210.canAccessRecord, 'optionalCall', _211 => _211(ctx, record)]));
+        collected.push(...filtered);
+        dbOffset += batch.records.length;
+        totalScanned += batch.records.length;
+        if (batch.records.length < batchSize) {
+          exhausted = true;
+          break;
+        }
+      }
+      effectiveTotal = exhausted ? collected.length : Math.max(collected.length, result.total);
+      filteredRecords = collected.slice(requestedOffset, requestedOffset + requestedLimit);
+    }
+    filteredRecords = await this.relationPropertiesService.enrichRecordsBatch(
+      filteredRecords,
+      schema
+    );
+    if (!_optionalChain([options, 'optionalAccess', _212 => _212.skipFormulas])) {
       return {
         records: enrichRecordsWithFormulas(filteredRecords, schema),
         total: effectiveTotal
@@ -10360,459 +10948,119 @@ var RecordQueryService = class extends BaseService {
    * Internal search query execution
    */
   async executeSearchQuery(schema, objectId, query, options) {
-    if (_optionalChain([this, 'access', _205 => _205.options, 'optionalAccess', _206 => _206.permissionService]) && this.userId) {
+    if (_optionalChain([this, 'access', _213 => _213.options, 'optionalAccess', _214 => _214.permissionService]) && this.userId) {
       await checkPermission(this.options.permissionService, this.userId, schema.name, "read");
     }
     const result = await runWithSchemaContext(
       [schema],
       () => this.adapter.objectRecords.search(objectId, query, options)
     );
-    if (!_optionalChain([options, 'optionalAccess', _207 => _207.skipFormulas])) {
+    const enrichedRecords = await this.relationPropertiesService.enrichRecordsBatch(
+      result.records,
+      schema
+    );
+    if (!_optionalChain([options, 'optionalAccess', _215 => _215.skipFormulas])) {
       return {
-        records: enrichRecordsWithFormulas(result.records, schema),
+        records: enrichRecordsWithFormulas(enrichedRecords, schema),
         total: result.total
       };
     }
-    return result;
-  }
-  // ============================================================================
-  // INCLUDE RELATIONS WITH PROPERTIES
-  // ============================================================================
-  /**
-   * Include relation properties in records.
-   *
-   * For each requested relation attribute:
-   * - If attribute has properties → Fetch from relation_attributes and return hybrid format
-   * - If attribute has NO properties → Return legacy format (string[] or string)
-   *
-   * Uses batch loading to avoid N+1 queries.
-   *
-   * @param records - Records to enrich with relation properties
-   * @param schema - Object schema
-   * @param includes - Array of relation attribute names to include
-   * @returns Records enriched with relation properties in hybrid format
-   * @private
-   */
-  async includeRelationsWithProperties(records, schema, includes) {
-    if (records.length === 0 || includes.length === 0) {
-      return records;
-    }
-    for (const includeName of includes) {
-      const attr = schema.attributes.find((a) => a.name === includeName);
-      if (!attr || attr.type !== "relation") {
-        continue;
-      }
-      if (attr.properties && this.adapter.relationAttributes) {
-        const recordIds = records.map((r) => r.id);
-        const relationAttributesRepo = this.adapter.relationAttributes;
-        const allRelationProps = await Promise.all(
-          recordIds.map(
-            (recordId) => relationAttributesRepo.findBySource(schema.name, recordId, includeName)
-          )
-        );
-        const propsByRecord = /* @__PURE__ */ new Map();
-        allRelationProps.forEach((props, index) => {
-          const recordId = recordIds[index];
-          const propsMap = /* @__PURE__ */ new Map();
-          for (const prop of props) {
-            propsMap.set(prop.toId, prop.properties);
-          }
-          propsByRecord.set(recordId, propsMap);
-        });
-        for (const record of records) {
-          const currentValue = record.values[includeName];
-          const propsMap = propsByRecord.get(record.id);
-          if (!currentValue) {
-            continue;
-          }
-          if (!propsMap) {
-            continue;
-          }
-          if (attr.cardinality === "many" && Array.isArray(currentValue)) {
-            record.values[includeName] = currentValue.map((id) => {
-              if (typeof id === "string") {
-                const props = propsMap.get(id);
-                return props ? { id, props } : { id };
-              }
-              return id;
-            });
-          } else if (attr.cardinality === "one") {
-            const id = typeof currentValue === "string" ? currentValue : null;
-            if (id) {
-              const props = propsMap.get(id);
-              record.values[includeName] = props ? { id, props } : { id };
-            }
-          }
-        }
-      }
-    }
-    return records;
-  }
-};
-
-// src/runtime/services/record/record-resolver.service.ts
-var RecordResolverService = class extends BaseService {
-  constructor(adapter) {
-    super(adapter);
-  }
-  // ============================================================================
-  // CACHED RECORD ACCESS
-  // ============================================================================
-  /**
-   * Find a record by ID with caching.
-   *
-   * Uses the shared record cache for optimal performance.
-   * Delegates to findByIds for consistent cache handling.
-   *
-   * @param id - Record ID
-   * @returns Record or null if not found
-   */
-  async findById(id) {
-    if (!id) return null;
-    const results = await this.findByIds([id]);
-    return _nullishCoalesce(results[0], () => ( null));
-  }
-  /**
-   * Find multiple records by IDs with caching.
-   *
-   * Each record is cached individually for reuse across services.
-   * Only fetches records not already in cache.
-   *
-   * @param ids - Record IDs to fetch
-   * @returns Array of found records (missing IDs are not included)
-   */
-  async findByIds(ids) {
-    if (!ids || ids.length === 0) {
-      return [];
-    }
-    const uniqueIds = [...new Set(ids)];
-    return this.cachedByMany(
-      "record",
-      uniqueIds,
-      (missingIds) => this.adapter.objectRecords.findByIds(missingIds),
-      (record) => record.id,
-      cacheTtl.records
-    );
-  }
-  // ============================================================================
-  // FACTORY METHODS
-  // ============================================================================
-  /**
-   * Create a RelationLabelResolver callback for computeLabelWithRelations.
-   *
-   * Used by RelationService.resolveLabel() and ObjectSchemaService.
-   *
-   * @returns Callback that resolves record IDs to their labels (cached)
-   */
-  createRelationLabelResolver() {
-    return async (ids) => {
-      const records = await this.findByIds(ids);
-      return new Map(records.map((r) => [r.id, r.label]));
-    };
-  }
-  /**
-   * Create a LabelResolver interface for label computation helpers.
-   *
-   * Used by RecordService for computing record labels.
-   *
-   * @param relationService - RelationService for resolving relation display labels
-   * @returns LabelResolver interface with cached record fetching
-   */
-  createLabelResolver(relationService) {
-    return {
-      resolveRelationIds: (ids, attrId) => relationService.resolveIds(ids, attrId),
-      findRecordLabels: (ids) => this.findByIds(ids)
-    };
-  }
-  /**
-   * Create a RollupCascadeContext for rollup recalculation.
-   *
-   * Used by RecordService after create/update/delete operations.
-   *
-   * @param rollupService - RollupService for recalculating rollups
-   * @param schemaService - ObjectSchemaService for fetching schemas
-   * @returns Context with cached record fetching
-   */
-  createRollupContext(rollupService, schemaService) {
-    return {
-      rollupService,
-      schemaService,
-      findRecordsByIds: (ids) => this.findByIds(ids)
-    };
-  }
-};
-
-// src/runtime/services/record/relation-properties.service.ts
-
-var RelationPropertiesService = class extends BaseService {
-  constructor(adapter) {
-    super(adapter);
-  }
-  // ============================================================================
-  // PUBLIC API
-  // ============================================================================
-  /**
-   * Normalize relation values for storage in object_records table.
-   *
-   * Extracts IDs from hybrid format ({ id, props }) and returns legacy format (string[] or string).
-   * This ensures object_records.values only contains IDs, while properties are in relation_attributes.
-   *
-   * @param schema - Object schema
-   * @param data - Record data with hybrid relation values
-   * @returns Data with relation values normalized to ID-only format
-   */
-  normalizeRelationValuesForStorage(schema, data) {
-    const normalized = { ...data };
-    for (const attr of schema.attributes) {
-      if (attr.type !== "relation" || !attr.properties) {
-        continue;
-      }
-      const value = data[attr.name];
-      if (value === null || value === void 0) {
-        continue;
-      }
-      if (attr.cardinality === "many" && Array.isArray(value)) {
-        normalized[attr.name] = value.map((item) => {
-          if (typeof item === "string") return item;
-          if (typeof item === "object" && item !== null && "id" in item) {
-            return item.id;
-          }
-          return item;
-        });
-      } else if (typeof value === "object" && value !== null && "id" in value) {
-        normalized[attr.name] = value.id;
-      }
-    }
-    return normalized;
+    return {
+      records: enrichedRecords,
+      total: result.total
+    };
+  }
+};
+
+// src/runtime/services/record/record-resolver.service.ts
+var RecordResolverService = class extends BaseService {
+  constructor(adapter) {
+    super(adapter);
   }
+  // ============================================================================
+  // CACHED RECORD ACCESS
+  // ============================================================================
   /**
-   * Synchronize relation properties for a given attribute.
+   * Find a record by ID with caching.
    *
-   * Handles:
-   * - Format normalization (legacy → new)
-   * - Validation of properties
-   * - Upsert for present IDs
-   * - Delete for absent IDs
+   * Uses the shared record cache for optimal performance.
+   * Delegates to findByIds for consistent cache handling.
    *
-   * @param schema - Object schema
-   * @param recordId - Source record ID
-   * @param attributeName - Relation attribute name
-   * @param relationValue - Relation value (hybrid format)
-   * @param adapter - Database adapter
+   * @param id - Record ID
+   * @returns Record or null if not found
    */
-  async syncRelationProperties(schema, recordId, attributeName, relationValue, adapter) {
-    const attribute = schema.attributes.find((a) => a.name === attributeName);
-    if (!attribute || attribute.type !== "relation") {
-      return;
-    }
-    if (!attribute.properties) {
-      return;
-    }
-    const normalized = this.normalizeRelationValue(relationValue);
-    for (const item of normalized) {
-      if (item.props) {
-        this.validateProperties(attribute.properties, item.props);
-      }
-    }
-    const existing = await _optionalChain([adapter, 'access', _208 => _208.relationAttributes, 'optionalAccess', _209 => _209.findBySource, 'call', _210 => _210(
-      schema.name,
-      recordId,
-      attributeName
-    )]);
-    const existingIds = new Set((_nullishCoalesce(existing, () => ( []))).map((r) => r.toId));
-    const newIds = new Set(normalized.map((item) => item.id));
-    const toUpsert = normalized.filter((item) => item.props !== void 0);
-    const toDelete = Array.from(existingIds).filter((id) => !newIds.has(id));
-    if (toUpsert.length > 0 && adapter.relationAttributes) {
-      const inputs = toUpsert.map((item) => ({
-        fromObject: schema.name,
-        fromId: recordId,
-        fromAttribute: attributeName,
-        toId: item.id,
-        properties: _nullishCoalesce(item.props, () => ( {})),
-        updatedBy: _nullishCoalesce(this.userId, () => ( void 0)),
-        createdBy: _nullishCoalesce(this.userId, () => ( void 0))
-      }));
-      await adapter.relationAttributes.upsertBatch(inputs);
-    }
-    if (toDelete.length > 0 && adapter.relationAttributes && existing) {
-      for (const toId of toDelete) {
-        const relation2 = existing.find((r) => r.toId === toId);
-        if (relation2) {
-        }
-      }
-      await adapter.relationAttributes.deleteBySource(schema.name, recordId, attributeName);
-      if (toUpsert.length > 0) {
-        const inputs = toUpsert.map((item) => ({
-          fromObject: schema.name,
-          fromId: recordId,
-          fromAttribute: attributeName,
-          toId: item.id,
-          properties: _nullishCoalesce(item.props, () => ( {})),
-          updatedBy: _nullishCoalesce(this.userId, () => ( void 0)),
-          createdBy: _nullishCoalesce(this.userId, () => ( void 0))
-        }));
-        await adapter.relationAttributes.upsertBatch(inputs);
-      }
-    }
+  async findById(id) {
+    if (!id) return null;
+    const results = await this.findByIds([id]);
+    return _nullishCoalesce(results[0], () => ( null));
   }
   /**
-   * Validate relation properties against PropertySchema.
+   * Find multiple records by IDs with caching.
    *
-   * Uses Zod for runtime validation based on PropertyDefinition types.
+   * Each record is cached individually for reuse across services.
+   * Only fetches records not already in cache.
    *
-   * @param propertySchema - Schema defining allowed properties
-   * @param properties - Properties to validate
-   * @throws {z.ZodError} if validation fails
+   * @param ids - Record IDs to fetch
+   * @returns Array of found records (missing IDs are not included)
    */
-  validateProperties(propertySchema, properties) {
-    const schema = this.buildZodSchema(propertySchema);
-    schema.parse(properties);
+  async findByIds(ids) {
+    if (!ids || ids.length === 0) {
+      return [];
+    }
+    const uniqueIds = [...new Set(ids)];
+    return this.cachedByMany(
+      "record",
+      uniqueIds,
+      (missingIds) => this.adapter.objectRecords.findByIds(missingIds),
+      (record) => record.id,
+      cacheTtl.records
+    );
   }
   // ============================================================================
-  // PRIVATE HELPERS
+  // FACTORY METHODS
   // ============================================================================
   /**
-   * Normalize relation value to unified internal format.
+   * Create a RelationLabelResolver callback for computeLabelWithRelations.
    *
-   * Converts:
-   * - string[] → Array<{ id, props?: undefined }>
-   * - string → [{ id, props?: undefined }]
-   * - null → []
-   * - Array<{ id, props }> → Array<{ id, props }> (passthrough)
-   * - { id, props } → [{ id, props }] (single to array)
+   * Used by RelationService.resolveLabel() and ObjectSchemaService.
    *
-   * @param value - Relation value in hybrid format
-   * @returns Normalized array of relation items
-   * @private
+   * @returns Callback that resolves record IDs to their labels (cached)
    */
-  normalizeRelationValue(value) {
-    if (value === null || value === void 0) {
-      return [];
-    }
-    if (typeof value === "string") {
-      return [{ id: value }];
-    }
-    if (!Array.isArray(value) && typeof value === "object" && "id" in value) {
-      return [value];
-    }
-    if (Array.isArray(value)) {
-      return value.map((item) => {
-        if (typeof item === "string") {
-          return { id: item };
-        }
-        return item;
-      });
-    }
-    return [];
+  createRelationLabelResolver() {
+    return async (ids) => {
+      const records = await this.findByIds(ids);
+      return new Map(records.map((r) => [r.id, r.label]));
+    };
   }
   /**
-   * Build Zod schema from PropertySchema definition.
+   * Create a LabelResolver interface for label computation helpers.
    *
-   * Dynamically generates validation schema based on PropertyDefinition types.
+   * Used by RecordService for computing record labels.
    *
-   * @param propertySchema - PropertySchema with definitions
-   * @returns Zod schema for validation
-   * @private
+   * @param relationService - RelationService for resolving relation display labels
+   * @returns LabelResolver interface with cached record fetching
    */
-  buildZodSchema(propertySchema) {
-    const shape = {};
-    for (const def of propertySchema.definitions) {
-      let fieldSchema = this.buildFieldSchema(def);
-      if (!def.required) {
-        fieldSchema = fieldSchema.optional();
-      }
-      shape[def.name] = fieldSchema;
-    }
-    return _zod.z.object(shape);
+  createLabelResolver(relationService) {
+    return {
+      resolveRelationIds: (ids, attrId) => relationService.resolveIds(ids, attrId),
+      findRecordLabels: (ids) => this.findByIds(ids)
+    };
   }
   /**
-   * Build Zod schema for a single property field.
+   * Create a RollupCascadeContext for rollup recalculation.
    *
-   * @param def - PropertyDefinition
-   * @returns Zod schema for the field
-   * @private
+   * Used by RecordService after create/update/delete operations.
+   *
+   * @param rollupService - RollupService for recalculating rollups
+   * @param schemaService - ObjectSchemaService for fetching schemas
+   * @returns Context with cached record fetching
    */
-  buildFieldSchema(def) {
-    switch (def.type) {
-      case "text":
-      case "textarea": {
-        let schema = _zod.z.string();
-        if (def.minLength !== void 0) {
-          schema = schema.min(def.minLength);
-        }
-        if (def.maxLength !== void 0) {
-          schema = schema.max(def.maxLength);
-        }
-        if (def.type === "text" && def.pattern) {
-          schema = schema.regex(new RegExp(def.pattern));
-        }
-        return schema;
-      }
-      case "number": {
-        let schema = _zod.z.number();
-        if (def.min !== void 0) {
-          schema = schema.min(def.min);
-        }
-        if (def.max !== void 0) {
-          schema = schema.max(def.max);
-        }
-        if (def.integer) {
-          schema = schema.int();
-        }
-        return schema;
-      }
-      case "checkbox": {
-        return _zod.z.boolean();
-      }
-      case "date": {
-        const schema = _zod.z.string().datetime();
-        return schema;
-      }
-      case "phone": {
-        return _zod.z.string();
-      }
-      case "currency": {
-        let schema = _zod.z.number();
-        if (def.min !== void 0) {
-          schema = schema.min(def.min);
-        }
-        if (def.max !== void 0) {
-          schema = schema.max(def.max);
-        }
-        return schema;
-      }
-      case "status":
-      case "select": {
-        const validValues = def.options.map((opt) => opt.value);
-        return _zod.z.enum(validValues);
-      }
-      case "multiselect": {
-        const validValues = def.options.map((opt) => opt.value);
-        let schema = _zod.z.array(_zod.z.enum(validValues));
-        if (def.maxSelections !== void 0) {
-          schema = schema.max(def.maxSelections);
-        }
-        return schema;
-      }
-      case "rating": {
-        let schema = _zod.z.number().int();
-        if (def.max !== void 0) {
-          schema = schema.max(def.max);
-        }
-        return schema.min(0);
-      }
-      case "location": {
-        return _zod.z.object({
-          address: _zod.z.string().optional(),
-          lat: _zod.z.number().optional(),
-          lng: _zod.z.number().optional()
-        });
-      }
-      default: {
-        return _zod.z.unknown();
-      }
-    }
+  createRollupContext(rollupService, schemaService) {
+    return {
+      rollupService,
+      schemaService,
+      findRecordsByIds: (ids) => this.findByIds(ids)
+    };
   }
 };
 
@@ -10823,6 +11071,7 @@ var RelationService = class extends BaseService {
     this.schemaService = new ObjectSchemaService(adapter, nativeRegistry);
     this.queryService = options.queryService;
     this.recordResolver = options.recordResolver;
+    this.relationPropertiesService = options.relationPropertiesService;
   }
   /**
    * Set the query service after construction.
@@ -10893,7 +11142,7 @@ var RelationService = class extends BaseService {
     }
     const isUniversal = attr.targets.length === 1 && attr.targets[0].object === RELATION_TARGET_ANY;
     const validObjectIds = isUniversal ? null : await this.getValidObjectIds(attr.targets);
-    if (!isUniversal && _optionalChain([validObjectIds, 'optionalAccess', _211 => _211.size]) === 0) {
+    if (!isUniversal && _optionalChain([validObjectIds, 'optionalAccess', _216 => _216.size]) === 0) {
       errors.push({
         attribute: attr.name,
         message: `No valid target objects found for ${attr.label}`
@@ -10946,10 +11195,10 @@ var RelationService = class extends BaseService {
     for (const target of targets) {
       try {
         const objectSchema = await this.schemaService.getObjectSchemaByName(target.object);
-        if (_optionalChain([objectSchema, 'optionalAccess', _212 => _212.id])) {
+        if (_optionalChain([objectSchema, 'optionalAccess', _217 => _217.id])) {
           objectIds.add(objectSchema.id);
         }
-      } catch (e12) {
+      } catch (e15) {
       }
     }
     return objectIds;
@@ -11015,7 +11264,7 @@ var RelationService = class extends BaseService {
     const targetResults = await Promise.all(
       filteredTargets.map(async (target) => {
         const objectSchema = await this.schemaService.getObjectSchemaByName(target.object);
-        if (!_optionalChain([objectSchema, 'optionalAccess', _213 => _213.id])) return { options: [], total: 0 };
+        if (!_optionalChain([objectSchema, 'optionalAccess', _218 => _218.id])) return { options: [], total: 0 };
         const objectId = objectSchema.id;
         const result = query ? await queryService.searchRecords(objectId, query, queryOptions) : await queryService.listRecords(objectId, queryOptions);
         const options = await Promise.all(
@@ -11172,8 +11421,8 @@ var RelationService = class extends BaseService {
         continue;
       }
       const attribute = attributeMap.get(attributeId);
-      const targetConfig = _optionalChain([attribute, 'optionalAccess', _214 => _214.targets, 'optionalAccess', _215 => _215.find, 'call', _216 => _216((t) => t.object === objectSchema.name)]);
-      const customTemplate = _optionalChain([targetConfig, 'optionalAccess', _217 => _217.displayTemplate]);
+      const targetConfig = _optionalChain([attribute, 'optionalAccess', _219 => _219.targets, 'optionalAccess', _220 => _220.find, 'call', _221 => _221((t) => t.object === objectSchema.name)]);
+      const customTemplate = _optionalChain([targetConfig, 'optionalAccess', _222 => _222.displayTemplate]);
       const label = await this.resolveLabel(record, objectSchema, customTemplate);
       resolved.push({
         _compositeId: compositeId,
@@ -11190,20 +11439,33 @@ var RelationService = class extends BaseService {
   /**
    * Resolve the display label for a record.
    * Uses custom template if provided, otherwise falls back to pre-computed label.
+   *
+   * Preserves `{{ props.X }}` tokens for client-side substitution using a sentinel approach:
+   * tokens are replaced with null-byte sentinels before template rendering, then restored after.
+   * This lets `computeLabelWithRelations` resolve target fields while keeping prop placeholders intact.
    */
   async resolveLabel(record, objectSchema, customTemplate) {
-    if (customTemplate) {
-      return computeLabelWithRelations(
-        customTemplate,
-        record.values,
-        objectSchema.attributes,
-        async (nestedIds) => {
-          const linkedRecords = await this.recordResolver.findByIds(nestedIds);
-          return new Map(linkedRecords.map((r) => [r.id, r.label]));
-        }
-      );
+    if (!customTemplate) return record.label;
+    const preserved = [];
+    let i = 0;
+    const safeTemplate = customTemplate.replace(/\{\{\s*props\.\w+[^}]*\}\}/g, (match) => {
+      const key = `\0PROP${i++}\0`;
+      preserved.push([key, match]);
+      return key;
+    });
+    let label = await computeLabelWithRelations(
+      safeTemplate,
+      record.values,
+      objectSchema.attributes,
+      async (nestedIds) => {
+        const linkedRecords = await this.recordResolver.findByIds(nestedIds);
+        return new Map(linkedRecords.map((r) => [r.id, r.label]));
+      }
+    );
+    for (const [key, token] of preserved) {
+      label = label.replace(key, token);
     }
-    return record.label;
+    return label;
   }
   /**
    * Find a relation attribute by ID.
@@ -11323,14 +11585,14 @@ var RollupService = class extends BaseService {
     const sourceSchema = getSchemaByNameFromContext(sourceObjectName);
     let sourceObjectId;
     let reverseRelationAttrName;
-    if (_optionalChain([sourceSchema, 'optionalAccess', _218 => _218.id])) {
+    if (_optionalChain([sourceSchema, 'optionalAccess', _223 => _223.id])) {
       sourceObjectId = sourceSchema.id;
       const reverseRelationAttr = sourceSchema.attributes.find((attr) => {
         if (attr.type !== "relation") return false;
         const relationConfig = attr;
-        return _optionalChain([relationConfig, 'optionalAccess', _219 => _219.targets, 'optionalAccess', _220 => _220.some, 'call', _221 => _221((t) => t.object === schema.name)]);
+        return _optionalChain([relationConfig, 'optionalAccess', _224 => _224.targets, 'optionalAccess', _225 => _225.some, 'call', _226 => _226((t) => t.object === schema.name)]);
       });
-      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _222 => _222.name]);
+      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _227 => _227.name]);
     } else {
       const sourceObject = await this.adapter.objects.findByName(sourceObjectName);
       if (!sourceObject) {
@@ -11341,9 +11603,9 @@ var RollupService = class extends BaseService {
       const reverseRelationAttr = sourceAttributes.find((attr) => {
         if (attr.type !== "relation") return false;
         const relationConfig = attr.config;
-        return _optionalChain([relationConfig, 'optionalAccess', _223 => _223.targets, 'optionalAccess', _224 => _224.some, 'call', _225 => _225((t) => t.object === schema.name)]);
+        return _optionalChain([relationConfig, 'optionalAccess', _228 => _228.targets, 'optionalAccess', _229 => _229.some, 'call', _230 => _230((t) => t.object === schema.name)]);
       });
-      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _226 => _226.name]);
+      reverseRelationAttrName = _optionalChain([reverseRelationAttr, 'optionalAccess', _231 => _231.name]);
     }
     if (!reverseRelationAttrName) {
       return { value: null, recordCount: 0 };
@@ -11599,13 +11861,13 @@ var RollupService = class extends BaseService {
       if (!obj) continue;
       for (const rollupDbAttr of rollupAttrs) {
         const rollupConfig = rollupDbAttr.config;
-        if (!_optionalChain([rollupConfig, 'optionalAccess', _227 => _227.relationAttribute])) continue;
+        if (!_optionalChain([rollupConfig, 'optionalAccess', _232 => _232.relationAttribute])) continue;
         const relationAttr = attributes.find(
           (a) => a.type === "relation" && a.name === rollupConfig.relationAttribute
         );
         if (!relationAttr) continue;
         const relationConfig = relationAttr.config;
-        const targetsChangedObject = _optionalChain([relationConfig, 'optionalAccess', _228 => _228.targets, 'optionalAccess', _229 => _229.some, 'call', _230 => _230(
+        const targetsChangedObject = _optionalChain([relationConfig, 'optionalAccess', _233 => _233.targets, 'optionalAccess', _234 => _234.some, 'call', _235 => _235(
           (t) => t.object === changedSchema.name
         )]);
         if (!targetsChangedObject) continue;
@@ -11630,11 +11892,11 @@ var RecordService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
     this.schemaService = new ObjectSchemaService(adapter, registry, {
-      auditService: _optionalChain([options, 'optionalAccess', _231 => _231.auditService])
+      auditService: _optionalChain([options, 'optionalAccess', _236 => _236.auditService])
     });
-    this.permissionService = _optionalChain([options, 'optionalAccess', _232 => _232.permissionService]);
-    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _233 => _233.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
-    this.policyRegistry = _optionalChain([options, 'optionalAccess', _234 => _234.policyRegistry]) === null ? null : _nullishCoalesce(_optionalChain([options, 'optionalAccess', _235 => _235.policyRegistry]), () => ( defaultPolicyRegistry));
+    this.permissionService = _optionalChain([options, 'optionalAccess', _237 => _237.permissionService]);
+    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _238 => _238.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
+    this.policyRegistry = _optionalChain([options, 'optionalAccess', _239 => _239.policyRegistry]) === null ? null : _nullishCoalesce(_optionalChain([options, 'optionalAccess', _240 => _240.policyRegistry]), () => ( defaultPolicyRegistry));
     this.recordResolver = new RecordResolverService(adapter);
     this.queryService = new RecordQueryService(adapter, this.schemaService, {
       permissionService: this.permissionService,
@@ -11649,7 +11911,12 @@ var RecordService = class extends BaseService {
       recordResolver: this.recordResolver
     });
     this.userService = new UserService(adapter);
-    this.hookRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _236 => _236.hookRegistry]), () => ( new NoopHookRegistry()));
+    this.hookRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _241 => _241.hookRegistry]), () => ( new NoopHookRegistry()));
+    this.bilateralSyncService = new BilateralSyncService(
+      adapter,
+      this.schemaService,
+      this.relationPropertiesService
+    );
     this.labelResolver = this.recordResolver.createLabelResolver(this.relationService);
     this.rollupContext = this.recordResolver.createRollupContext(
       this.rollupService,
@@ -11684,25 +11951,25 @@ var RecordService = class extends BaseService {
       schema,
       this.tenantId,
       dataWithDefaults,
-      _optionalChain([options, 'optionalAccess', _237 => _237.hookMetadata])
+      _optionalChain([options, 'optionalAccess', _242 => _242.hookMetadata])
     );
-    if (!_optionalChain([options, 'optionalAccess', _238 => _238.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _243 => _243.skipHooks])) {
       await this.hookRegistry.execute("beforeCreate", schema.name, hookCtx);
     }
     const normalizedData = this.relationPropertiesService.normalizeRelationValuesForStorage(
       schema,
       dataWithDefaults
     );
-    if (_optionalChain([options, 'optionalAccess', _239 => _239.validate]) !== false) {
-      if (_optionalChain([options, 'optionalAccess', _240 => _240.allowDraft])) {
+    if (_optionalChain([options, 'optionalAccess', _244 => _244.validate]) !== false) {
+      if (_optionalChain([options, 'optionalAccess', _245 => _245.allowDraft])) {
         _chunkU4AB53AMjs.validateDraftOrThrow.call(void 0, schema, normalizedData);
       } else {
         _chunkU4AB53AMjs.validateObjectOrThrow.call(void 0, schema, normalizedData);
       }
-      if (!_optionalChain([options, 'optionalAccess', _241 => _241.skipRelationValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _246 => _246.skipRelationValidation])) {
         await this.relationService.validateRelationsOrThrow(schema, normalizedData);
       }
-      if (!_optionalChain([options, 'optionalAccess', _242 => _242.skipUserValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _247 => _247.skipUserValidation])) {
         await this.userService.validateUsersOrThrow(schema, normalizedData);
       }
     }
@@ -11713,22 +11980,39 @@ var RecordService = class extends BaseService {
       data: normalizedData,
       label,
       completionStatus,
-      metadata: _optionalChain([options, 'optionalAccess', _243 => _243.metadata]),
+      metadata: _optionalChain([options, 'optionalAccess', _248 => _248.metadata]),
       createdBy: this.userId
     });
     for (const [attrName, value] of Object.entries(dataWithDefaults)) {
       const attr = schema.attributes.find((a) => a.name === attrName);
-      if (_optionalChain([attr, 'optionalAccess', _244 => _244.type]) === "relation" && attr.properties) {
-        await this.relationPropertiesService.syncRelationProperties(
+      if (_optionalChain([attr, 'optionalAccess', _249 => _249.type]) === "relation") {
+        const hasProperties2 = attr.properties !== void 0;
+        const isBilateral = isBilateralRelation(attr);
+        if (hasProperties2 || isBilateral) {
+          await this.relationPropertiesService.syncRelationProperties(
+            schema,
+            record.id,
+            attrName,
+            value,
+            this.adapter
+          );
+        }
+      }
+    }
+    for (const [attrName, value] of Object.entries(normalizedData)) {
+      const attr = schema.attributes.find((a) => a.name === attrName);
+      if (_optionalChain([attr, 'optionalAccess', _250 => _250.type]) === "relation" && isBilateralRelation(attr)) {
+        await this.bilateralSyncService.syncBilateralRelation(
           schema,
           record.id,
           attrName,
           value,
-          this.adapter
+          null
+          // oldValue is null for create
         );
       }
     }
-    if (!_optionalChain([options, 'optionalAccess', _245 => _245.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _251 => _251.skipHooks])) {
       const afterCtx = {
         ...hookCtx,
         recordId: record.id,
@@ -11746,12 +12030,8 @@ var RecordService = class extends BaseService {
         objectId: schema.id,
         recordId: record.id,
         recordLabel: record.label,
-        metadata: _optionalChain([options, 'optionalAccess', _246 => _246.hookMetadata])
-      }).catch((err) => {
-        console.error(
-          "Audit log failed (record.created):",
-          err instanceof Error ? err.message : err
-        );
+        metadata: _optionalChain([options, 'optionalAccess', _252 => _252.hookMetadata])
+      }).catch(() => {
       });
     }
     return record;
@@ -11772,7 +12052,7 @@ var RecordService = class extends BaseService {
       return null;
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
-    if (!_optionalChain([options, 'optionalAccess', _247 => _247.skipPolicyCheck])) {
+    if (!_optionalChain([options, 'optionalAccess', _253 => _253.skipPolicyCheck])) {
       const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
       if (policy) {
         const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
@@ -11782,10 +12062,11 @@ var RecordService = class extends BaseService {
       }
     }
     let enrichedRecord = record;
-    if (!_optionalChain([options, 'optionalAccess', _248 => _248.skipFormulas])) {
+    if (!_optionalChain([options, 'optionalAccess', _254 => _254.skipFormulas])) {
       enrichedRecord = enrichWithFormulas(record, schema);
     }
-    if (_optionalChain([options, 'optionalAccess', _249 => _249.includeSchema])) {
+    enrichedRecord = await this.enrichRelationProperties(enrichedRecord, schema);
+    if (_optionalChain([options, 'optionalAccess', _255 => _255.includeSchema])) {
       const recordWithSchema = enrichedRecord;
       recordWithSchema.schema = schema;
       return recordWithSchema;
@@ -11835,7 +12116,7 @@ var RecordService = class extends BaseService {
       if (oldVal !== null && newVal !== null && typeof oldVal === "object" && typeof newVal === "object") {
         try {
           return JSON.stringify(oldVal) !== JSON.stringify(newVal);
-        } catch (e13) {
+        } catch (e16) {
           return true;
         }
       }
@@ -11847,9 +12128,9 @@ var RecordService = class extends BaseService {
       existing,
       mergedData,
       changedAttributes,
-      _optionalChain([options, 'optionalAccess', _250 => _250.hookMetadata])
+      _optionalChain([options, 'optionalAccess', _256 => _256.hookMetadata])
     );
-    if (!_optionalChain([options, 'optionalAccess', _251 => _251.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _257 => _257.skipHooks])) {
       await this.hookRegistry.execute("beforeUpdate", schema.name, hookCtx);
     }
     const hookModifiedValues = {};
@@ -11864,16 +12145,16 @@ var RecordService = class extends BaseService {
       dataToUpdate
     );
     const normalizedMergedData = { ...existing.values, ...normalizedUpdate };
-    if (_optionalChain([options, 'optionalAccess', _252 => _252.validate]) !== false) {
-      if (_optionalChain([options, 'optionalAccess', _253 => _253.partial])) {
+    if (_optionalChain([options, 'optionalAccess', _258 => _258.validate]) !== false) {
+      if (_optionalChain([options, 'optionalAccess', _259 => _259.partial])) {
         _chunkU4AB53AMjs.validateDraftOrThrow.call(void 0, schema, normalizedMergedData);
       } else {
         _chunkU4AB53AMjs.validateObjectOrThrow.call(void 0, schema, normalizedMergedData);
       }
-      if (!_optionalChain([options, 'optionalAccess', _254 => _254.skipRelationValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _260 => _260.skipRelationValidation])) {
         await this.relationService.validateRelationsOrThrow(schema, normalizedUpdate);
       }
-      if (!_optionalChain([options, 'optionalAccess', _255 => _255.skipUserValidation])) {
+      if (!_optionalChain([options, 'optionalAccess', _261 => _261.skipUserValidation])) {
         await this.userService.validateUsersOrThrow(schema, normalizedUpdate);
       }
     }
@@ -11886,7 +12167,7 @@ var RecordService = class extends BaseService {
       __lastUpdatedBy: this.userId,
       __expectedUpdatedAt: existing.updatedAt instanceof Date ? existing.updatedAt.toISOString() : existing.updatedAt
     };
-    if (_optionalChain([options, 'optionalAccess', _256 => _256.metadata]) !== void 0) {
+    if (_optionalChain([options, 'optionalAccess', _262 => _262.metadata]) !== void 0) {
       const existingMetadata = _nullishCoalesce(existing.metadata, () => ( {}));
       const mergedMetadata = { ...existingMetadata, ...options.metadata };
       const cleanedMetadata = Object.fromEntries(
@@ -11894,21 +12175,45 @@ var RecordService = class extends BaseService {
       );
       updatePayload.__metadata = cleanedMetadata;
     }
+    const bilateralOldValues = {};
+    for (const attrName of Object.keys(normalizedUpdate)) {
+      const attr = schema.attributes.find((a) => a.name === attrName);
+      if (_optionalChain([attr, 'optionalAccess', _263 => _263.type]) === "relation" && isBilateralRelation(attr)) {
+        bilateralOldValues[attrName] = existing.values[attrName];
+      }
+    }
     const updated = await this.adapter.objectRecords.update(recordId, updatePayload);
     await this.invalidateRecordCaches(recordId, existing.objectId);
     for (const [attrName, value] of Object.entries(dataToUpdate)) {
       const attr = schema.attributes.find((a) => a.name === attrName);
-      if (_optionalChain([attr, 'optionalAccess', _257 => _257.type]) === "relation" && attr.properties) {
-        await this.relationPropertiesService.syncRelationProperties(
+      if (_optionalChain([attr, 'optionalAccess', _264 => _264.type]) === "relation") {
+        const hasProperties2 = attr.properties !== void 0;
+        const isBilateral = isBilateralRelation(attr);
+        if (hasProperties2 || isBilateral) {
+          await this.relationPropertiesService.syncRelationProperties(
+            schema,
+            recordId,
+            attrName,
+            value,
+            this.adapter
+          );
+        }
+      }
+    }
+    for (const [attrName, value] of Object.entries(normalizedUpdate)) {
+      const attr = schema.attributes.find((a) => a.name === attrName);
+      if (_optionalChain([attr, 'optionalAccess', _265 => _265.type]) === "relation" && isBilateralRelation(attr)) {
+        const oldValue = bilateralOldValues[attrName];
+        await this.bilateralSyncService.syncBilateralRelation(
           schema,
           recordId,
           attrName,
           value,
-          this.adapter
+          oldValue
         );
       }
     }
-    if (!_optionalChain([options, 'optionalAccess', _258 => _258.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _266 => _266.skipHooks])) {
       const afterCtx = {
         ...hookCtx,
         record: updated
@@ -11923,7 +12228,7 @@ var RecordService = class extends BaseService {
     if (this.auditService && this.userId && allChangedAttributes.length > 0) {
       const changes = allChangedAttributes.map((attr) => ({
         field: attr,
-        oldValue: _optionalChain([hookCtx, 'access', _259 => _259.oldValues, 'optionalAccess', _260 => _260[attr]]),
+        oldValue: _optionalChain([hookCtx, 'access', _267 => _267.oldValues, 'optionalAccess', _268 => _268[attr]]),
         newValue: hookCtx.newValues[attr]
       }));
       this.auditService.logRecordAction({
@@ -11934,12 +12239,8 @@ var RecordService = class extends BaseService {
         recordId: updated.id,
         recordLabel: updated.label,
         changes,
-        metadata: _optionalChain([options, 'optionalAccess', _261 => _261.hookMetadata])
-      }).catch((err) => {
-        console.error(
-          "Audit log failed (record.updated):",
-          err instanceof Error ? err.message : err
-        );
+        metadata: _optionalChain([options, 'optionalAccess', _269 => _269.hookMetadata])
+      }).catch(() => {
       });
     }
     return updated;
@@ -11969,22 +12270,35 @@ var RecordService = class extends BaseService {
       const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
       checkRecordDeleteOrThrow(policy, record, ctx);
     }
-    if (_optionalChain([options, 'optionalAccess', _262 => _262.checkSystem]) && schema.system) {
+    if (_optionalChain([options, 'optionalAccess', _270 => _270.checkSystem]) && schema.system) {
       throw new ProtectedResourceError("object", schema.name, "delete");
     }
-    if (!_optionalChain([options, 'optionalAccess', _263 => _263.skipReferenceCheck])) {
+    if (!_optionalChain([options, 'optionalAccess', _271 => _271.skipReferenceCheck])) {
       const references = await this.adapter.objectRecords.countRecordsReferencingId(recordId);
       if (references.length > 0) {
         throw new RecordReferencedError(recordId, references);
       }
     }
-    const hookCtx = createContextForDelete(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _264 => _264.hookMetadata]));
-    if (!_optionalChain([options, 'optionalAccess', _265 => _265.skipHooks])) {
+    const hookCtx = createContextForDelete(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _272 => _272.hookMetadata]));
+    if (!_optionalChain([options, 'optionalAccess', _273 => _273.skipHooks])) {
       await this.hookRegistry.execute("beforeDelete", schema.name, hookCtx);
     }
+    for (const attr of schema.attributes) {
+      if (attr.type === "relation" && isBilateralRelation(attr)) {
+        const currentValue = record.values[attr.name];
+        await this.bilateralSyncService.syncBilateralRelation(
+          schema,
+          recordId,
+          attr.name,
+          null,
+          // newValue is null
+          currentValue
+        );
+      }
+    }
     await this.adapter.objectRecords.delete(recordId);
     await this.invalidateRecordCaches(recordId, record.objectId);
-    if (!_optionalChain([options, 'optionalAccess', _266 => _266.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _274 => _274.skipHooks])) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
     await recalculateParentRollups(record, schema, this.rollupContext);
@@ -11996,12 +12310,8 @@ var RecordService = class extends BaseService {
         objectId: schema.id,
         recordId: record.id,
         recordLabel: record.label,
-        metadata: _optionalChain([options, 'optionalAccess', _267 => _267.hookMetadata])
-      }).catch((err) => {
-        console.error(
-          "Audit log failed (record.deleted):",
-          err instanceof Error ? err.message : err
-        );
+        metadata: _optionalChain([options, 'optionalAccess', _275 => _275.hookMetadata])
+      }).catch(() => {
       });
     }
   }
@@ -12061,13 +12371,13 @@ var RecordService = class extends BaseService {
       this.tenantId
     );
     await checkPermission(this.permissionService, this.userId, schema.name, "update");
-    const hookCtx = createContextForRestore(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _268 => _268.hookMetadata]));
-    if (!_optionalChain([options, 'optionalAccess', _269 => _269.skipHooks])) {
+    const hookCtx = createContextForRestore(schema, this.tenantId, record, _optionalChain([options, 'optionalAccess', _276 => _276.hookMetadata]));
+    if (!_optionalChain([options, 'optionalAccess', _277 => _277.skipHooks])) {
       await this.hookRegistry.execute("beforeRestore", schema.name, hookCtx);
     }
     const restored = await this.adapter.objectRecords.restore(recordId);
     await this.invalidateRecordCaches(recordId, record.objectId);
-    if (!_optionalChain([options, 'optionalAccess', _270 => _270.skipHooks])) {
+    if (!_optionalChain([options, 'optionalAccess', _278 => _278.skipHooks])) {
       const afterCtx = {
         ...hookCtx,
         record: restored
@@ -12082,12 +12392,8 @@ var RecordService = class extends BaseService {
         objectId: schema.id,
         recordId: restored.id,
         recordLabel: restored.label,
-        metadata: _optionalChain([options, 'optionalAccess', _271 => _271.hookMetadata])
-      }).catch((err) => {
-        console.error(
-          "Audit log failed (record.restored):",
-          err instanceof Error ? err.message : err
-        );
+        metadata: _optionalChain([options, 'optionalAccess', _279 => _279.hookMetadata])
+      }).catch(() => {
       });
     }
     return restored;
@@ -12095,6 +12401,60 @@ var RecordService = class extends BaseService {
   // ============================================================================
   // PRIVATE HELPERS
   // ============================================================================
+  /**
+   * Enrich relation attributes with their properties (for qualified relations).
+   *
+   * Transforms simple ID arrays into hybrid format { id, props } when properties exist.
+   *
+   * @param record - Record to enrich
+   * @param schema - Object schema
+   * @returns Enriched record with relation properties loaded
+   * @private
+   */
+  async enrichRelationProperties(record, schema) {
+    const enrichedValues = { ...record.values };
+    for (const attr of schema.attributes) {
+      if (attr.type !== "relation") {
+        continue;
+      }
+      const hasProperties2 = attr.properties && attr.properties.definitions.length > 0;
+      const isBilateral = isBilateralRelation(attr);
+      const shouldEnrich = hasProperties2 || isBilateral;
+      if (!shouldEnrich) {
+        continue;
+      }
+      const value = record.values[attr.name];
+      if (value === null || value === void 0) {
+        continue;
+      }
+      const isMany = attr.cardinality === "many";
+      const targetIds = isMany ? value : [value];
+      if (!targetIds || targetIds.length === 0) {
+        continue;
+      }
+      const propsMap = await this.relationPropertiesService.getRelationProperties(
+        schema.name,
+        record.id,
+        attr.name,
+        targetIds
+      );
+      if (isMany) {
+        const hybridArray = targetIds.map((id) => {
+          const props = propsMap.get(id);
+          return props ? { id, props } : id;
+        });
+        enrichedValues[attr.name] = hybridArray;
+      } else {
+        const id = targetIds[0];
+        const props = propsMap.get(id);
+        enrichedValues[attr.name] = props ? { id, props } : id;
+      }
+    }
+    return {
+      ...record,
+      values: enrichedValues
+    };
+  }
   /**
    * Invalidate all caches related to a record (record cache + lists + global search)
    * @private
@@ -12463,7 +12823,7 @@ var DocumentRendererService = class {
       throw new StorageDownloadNotSupportedError();
     }
     let storagePath = fileId;
-    if (_optionalChain([this, 'access', _272 => _272.options, 'optionalAccess', _273 => _273.filesRepository])) {
+    if (_optionalChain([this, 'access', _280 => _280.options, 'optionalAccess', _281 => _281.filesRepository])) {
       const file2 = await this.options.filesRepository.findById(fileId);
       if (!file2) {
         throw new Error(`Template file not found: ${fileId}`);
@@ -12481,8 +12841,8 @@ var DocumentRendererService = class {
     for (const field of fields) {
       const rawValue = getContextValue(context, field.contextPath);
       const attrInfo = await this.getAttributeInfo(field.contextPath, workflow2);
-      if (_optionalChain([attrInfo, 'optionalAccess', _274 => _274.attribute])) {
-        if (attrInfo.attribute.type === "relation" && rawValue && _optionalChain([this, 'access', _275 => _275.options, 'optionalAccess', _276 => _276.relationService])) {
+      if (_optionalChain([attrInfo, 'optionalAccess', _282 => _282.attribute])) {
+        if (attrInfo.attribute.type === "relation" && rawValue && _optionalChain([this, 'access', _283 => _283.options, 'optionalAccess', _284 => _284.relationService])) {
           const ids = Array.isArray(rawValue) ? rawValue : [rawValue];
           const stringIds = ids.filter((id) => typeof id === "string");
           if (stringIds.length > 0) {
@@ -12503,7 +12863,7 @@ var DocumentRendererService = class {
         resolved.set(field.id, this.formatValueSimple(rawValue, field.fallback));
       }
     }
-    if (relationBatch.length > 0 && _optionalChain([this, 'access', _277 => _277.options, 'optionalAccess', _278 => _278.relationService])) {
+    if (relationBatch.length > 0 && _optionalChain([this, 'access', _285 => _285.options, 'optionalAccess', _286 => _286.relationService])) {
       try {
         const batchResult = await this.options.relationService.resolveIdsBatch(
           relationBatch.map((r) => ({ attributeId: r.attributeId, ids: r.ids }))
@@ -12512,12 +12872,12 @@ var DocumentRendererService = class {
           const options = _nullishCoalesce(batchResult[attributeId], () => ( []));
           const labels = options.map((o) => o.label);
           const field = fields.find((f) => f.id === fieldId);
-          resolved.set(fieldId, labels.join(", ") || _optionalChain([field, 'optionalAccess', _279 => _279.fallback]) || "");
+          resolved.set(fieldId, labels.join(", ") || _optionalChain([field, 'optionalAccess', _287 => _287.fallback]) || "");
         }
-      } catch (e14) {
+      } catch (e17) {
         for (const { fieldId, ids } of relationBatch) {
           const field = fields.find((f) => f.id === fieldId);
-          resolved.set(fieldId, ids.join(", ") || _optionalChain([field, 'optionalAccess', _280 => _280.fallback]) || "");
+          resolved.set(fieldId, ids.join(", ") || _optionalChain([field, 'optionalAccess', _288 => _288.fallback]) || "");
         }
       }
     }
@@ -12528,7 +12888,7 @@ var DocumentRendererService = class {
    * Parses paths like "slots.client.firstName" to find the attribute definition
    */
   async getAttributeInfo(contextPath, workflow2) {
-    const schemaService = _optionalChain([this, 'access', _281 => _281.options, 'optionalAccess', _282 => _282.schemaService]);
+    const schemaService = _optionalChain([this, 'access', _289 => _289.options, 'optionalAccess', _290 => _290.schemaService]);
     if (!schemaService) {
       return null;
     }
@@ -12541,7 +12901,7 @@ var DocumentRendererService = class {
     }
     const slotId = parts[1];
     const attributeName = parts[2];
-    const slot = _optionalChain([workflow2, 'access', _283 => _283.slots, 'optionalAccess', _284 => _284.find, 'call', _285 => _285((s) => s.id === slotId)]);
+    const slot = _optionalChain([workflow2, 'access', _291 => _291.slots, 'optionalAccess', _292 => _292.find, 'call', _293 => _293((s) => s.id === slotId)]);
     if (!slot) {
       return null;
     }
@@ -12550,7 +12910,7 @@ var DocumentRendererService = class {
       try {
         schema = await schemaService.getObjectSchemaByName(slot.objectName);
         this.schemaCache.set(slot.objectName, schema);
-      } catch (e15) {
+      } catch (e18) {
         return null;
       }
     }
@@ -12740,7 +13100,7 @@ var DocumentProcessingHook = class extends BaseService {
     const pendingIds = [];
     for (const [nodeId, doc] of Object.entries(context.documents)) {
       const metadata = doc.metadata;
-      if (_optionalChain([metadata, 'optionalAccess', _286 => _286.status]) === "pending") {
+      if (_optionalChain([metadata, 'optionalAccess', _294 => _294.status]) === "pending") {
         pendingIds.push(nodeId);
       }
     }
@@ -12791,12 +13151,12 @@ var DocumentProcessingHook = class extends BaseService {
     }
     for (const slotId of targetSlotIds) {
       try {
-        const recordId = _optionalChain([context, 'access', _287 => _287.createdRecordIds, 'optionalAccess', _288 => _288[slotId]]);
+        const recordId = _optionalChain([context, 'access', _295 => _295.createdRecordIds, 'optionalAccess', _296 => _296[slotId]]);
         if (!recordId) {
           continue;
         }
-        const slotDef = _optionalChain([workflow2, 'access', _289 => _289.slots, 'optionalAccess', _290 => _290.find, 'call', _291 => _291((s) => s.id === slotId)]);
-        const objectName = _optionalChain([slotDef, 'optionalAccess', _292 => _292.objectName]);
+        const slotDef = _optionalChain([workflow2, 'access', _297 => _297.slots, 'optionalAccess', _298 => _298.find, 'call', _299 => _299((s) => s.id === slotId)]);
+        const objectName = _optionalChain([slotDef, 'optionalAccess', _300 => _300.objectName]);
         if (!objectName) {
           continue;
         }
@@ -12813,14 +13173,14 @@ var DocumentProcessingHook = class extends BaseService {
         attachedDocumentIds.push(result.document.id);
         const record = await recordService.getRecord(recordId);
         if (record) {
-          const attachments = _nullishCoalesce(_optionalChain([record, 'access', _293 => _293.values, 'optionalAccess', _294 => _294.attachments]), () => ( []));
+          const attachments = _nullishCoalesce(_optionalChain([record, 'access', _301 => _301.values, 'optionalAccess', _302 => _302.attachments]), () => ( []));
           await recordService.updateRecord(
             recordId,
             { attachments: [...attachments, result.document.id] },
             { partial: true }
           );
         }
-      } catch (e16) {
+      } catch (e19) {
       }
     }
     return attachedDocumentIds;
@@ -13079,7 +13439,7 @@ var WorkflowAccessGrantService = class extends BaseService {
    * Check if a specific token has been revoked.
    */
   isTokenRevoked(dbGrant, jti) {
-    return _nullishCoalesce(_optionalChain([dbGrant, 'access', _295 => _295.revoked_token_jtis, 'optionalAccess', _296 => _296.includes, 'call', _297 => _297(jti)]), () => ( false));
+    return _nullishCoalesce(_optionalChain([dbGrant, 'access', _303 => _303.revoked_token_jtis, 'optionalAccess', _304 => _304.includes, 'call', _305 => _305(jti)]), () => ( false));
   }
   /**
    * Validate access token payload against the grant.
@@ -13131,10 +13491,10 @@ var WorkflowInstanceService = class extends BaseService {
   constructor(adapter, workflowService, options) {
     super(adapter);
     this.workflowService = workflowService;
-    this.executorRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _298 => _298.executorRegistry]), () => ( getDefaultExecutorRegistry()));
-    this.schemaService = _optionalChain([options, 'optionalAccess', _299 => _299.schemaService]);
-    this.recordService = _optionalChain([options, 'optionalAccess', _300 => _300.recordService]);
-    this.documentProcessingHook = _optionalChain([options, 'optionalAccess', _301 => _301.documentProcessingHook]);
+    this.executorRegistry = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _306 => _306.executorRegistry]), () => ( getDefaultExecutorRegistry()));
+    this.schemaService = _optionalChain([options, 'optionalAccess', _307 => _307.schemaService]);
+    this.recordService = _optionalChain([options, 'optionalAccess', _308 => _308.recordService]);
+    this.documentProcessingHook = _optionalChain([options, 'optionalAccess', _309 => _309.documentProcessingHook]);
   }
   /**
    * Start a new workflow instance
@@ -13316,7 +13676,7 @@ var WorkflowInstanceService = class extends BaseService {
     if (!this.adapter.workflowInstances) {
       return { instances: [], total: 0 };
     }
-    if (_optionalChain([options, 'optionalAccess', _302 => _302.workflowName])) {
+    if (_optionalChain([options, 'optionalAccess', _310 => _310.workflowName])) {
       const allDbInstances = await this.adapter.workflowInstances.findByWorkflowName(
         options.workflowName,
         { status: options.status }
@@ -13330,11 +13690,11 @@ var WorkflowInstanceService = class extends BaseService {
       return { instances: instances2, total: total2 };
     }
     const { instances: dbInstances, total } = await this.adapter.workflowInstances.list({
-      limit: _optionalChain([options, 'optionalAccess', _303 => _303.limit]),
-      offset: _optionalChain([options, 'optionalAccess', _304 => _304.offset])
+      limit: _optionalChain([options, 'optionalAccess', _311 => _311.limit]),
+      offset: _optionalChain([options, 'optionalAccess', _312 => _312.offset])
     });
     let instances = dbInstances.map((db) => this.convertDBInstanceToInstance(db));
-    if (_optionalChain([options, 'optionalAccess', _305 => _305.status])) {
+    if (_optionalChain([options, 'optionalAccess', _313 => _313.status])) {
       instances = instances.filter((i) => i.status === options.status);
     }
     instances = await this.markExpiredInstances(instances);
@@ -13355,9 +13715,9 @@ var WorkflowInstanceService = class extends BaseService {
       return { instances: [], total: 0 };
     }
     const { instances: dbInstances, total } = await this.adapter.workflowInstances.findByRecordInSlots(objectName, recordId, {
-      status: _optionalChain([options, 'optionalAccess', _306 => _306.status]),
-      limit: _optionalChain([options, 'optionalAccess', _307 => _307.limit]),
-      offset: _optionalChain([options, 'optionalAccess', _308 => _308.offset])
+      status: _optionalChain([options, 'optionalAccess', _314 => _314.status]),
+      limit: _optionalChain([options, 'optionalAccess', _315 => _315.limit]),
+      offset: _optionalChain([options, 'optionalAccess', _316 => _316.offset])
     });
     const instances = dbInstances.map((db) => this.convertDBInstanceToInstance(db));
     return { instances, total };
@@ -13423,13 +13783,13 @@ var WorkflowInstanceService = class extends BaseService {
         try {
           const schemas = await Promise.all(
             current.workflowSnapshot.slots.map(
-              (slot) => _optionalChain([this, 'access', _309 => _309.schemaService, 'optionalAccess', _310 => _310.getObjectSchemaByName, 'call', _311 => _311(slot.objectName)])
+              (slot) => _optionalChain([this, 'access', _317 => _317.schemaService, 'optionalAccess', _318 => _318.getObjectSchemaByName, 'call', _319 => _319(slot.objectName)])
             )
           );
           objectDefinitions = schemas.filter(
             (s) => s !== void 0
           );
-        } catch (e17) {
+        } catch (e20) {
         }
       }
       const executorContext = {
@@ -13688,9 +14048,9 @@ var WorkflowInstanceService = class extends BaseService {
    */
   async snapshotRecord(recordId) {
     try {
-      const record = await _optionalChain([this, 'access', _312 => _312.recordService, 'optionalAccess', _313 => _313.getRecord, 'call', _314 => _314(recordId, { skipPolicyCheck: true })]);
-      return _optionalChain([record, 'optionalAccess', _315 => _315.values]);
-    } catch (e18) {
+      const record = await _optionalChain([this, 'access', _320 => _320.recordService, 'optionalAccess', _321 => _321.getRecord, 'call', _322 => _322(recordId, { skipPolicyCheck: true })]);
+      return _optionalChain([record, 'optionalAccess', _323 => _323.values]);
+    } catch (e21) {
       return void 0;
     }
   }
@@ -13708,18 +14068,18 @@ var WorkflowInstanceService = class extends BaseService {
     for (const op of [...operations].reverse()) {
       try {
         if (op.operation === "create") {
-          await _optionalChain([this, 'access', _316 => _316.recordService, 'optionalAccess', _317 => _317.deleteRecord, 'call', _318 => _318(op.recordId, {
+          await _optionalChain([this, 'access', _324 => _324.recordService, 'optionalAccess', _325 => _325.deleteRecord, 'call', _326 => _326(op.recordId, {
             skipHooks: true,
             skipReferenceCheck: true
           })]);
           rolledBack.push(op.slotId);
         } else if (op.operation === "update" && op.previousData) {
-          await _optionalChain([this, 'access', _319 => _319.recordService, 'optionalAccess', _320 => _320.updateRecord, 'call', _321 => _321(op.recordId, op.previousData, {
+          await _optionalChain([this, 'access', _327 => _327.recordService, 'optionalAccess', _328 => _328.updateRecord, 'call', _329 => _329(op.recordId, op.previousData, {
             partial: false
           })]);
           rolledBack.push(op.slotId);
         }
-      } catch (e19) {
+      } catch (e22) {
       }
     }
     return rolledBack;
@@ -13838,7 +14198,7 @@ var WorkflowInstanceService = class extends BaseService {
     if (!this.adapter.workflowInstances) {
       return;
     }
-    const currentVersion = _nullishCoalesce(_optionalChain([instance, 'access', _322 => _322.context, 'access', _323 => _323.variables, 'optionalAccess', _324 => _324.__version]), () => ( 0));
+    const currentVersion = _nullishCoalesce(_optionalChain([instance, 'access', _330 => _330.context, 'access', _331 => _331.variables, 'optionalAccess', _332 => _332.__version]), () => ( 0));
     const nextVersion = currentVersion + 1;
     const instanceWithVersion = {
       ...instance,
@@ -14119,7 +14479,7 @@ var WorkflowRelationService = class extends BaseService {
         if (attr.type !== "relation") continue;
         for (const slot of slots) {
           const slotData = context.slots[slot.id];
-          const slotRecordId = _optionalChain([slotData, 'optionalAccess', _325 => _325.id]);
+          const slotRecordId = _optionalChain([slotData, 'optionalAccess', _333 => _333.id]);
           if (!slotRecordId) continue;
           const targetsSlotObject = attr.targets.some(
             (t) => t.object === slot.objectName
@@ -14187,7 +14547,7 @@ var WorkflowService = class extends BaseService {
     if (Array.isArray(options)) {
       this.systemWorkflows = new Map(options.map((w) => [w.name, w]));
     } else {
-      this.systemWorkflows = new Map((_nullishCoalesce(_optionalChain([options, 'optionalAccess', _326 => _326.systemWorkflows]), () => ( []))).map((w) => [w.name, w]));
+      this.systemWorkflows = new Map((_nullishCoalesce(_optionalChain([options, 'optionalAccess', _334 => _334.systemWorkflows]), () => ( []))).map((w) => [w.name, w]));
     }
   }
   // ============================================================================
@@ -14485,7 +14845,7 @@ var WorkflowService = class extends BaseService {
 var UserProfileService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
-    this.auditService = _optionalChain([options, 'optionalAccess', _327 => _327.auditService]);
+    this.auditService = _optionalChain([options, 'optionalAccess', _335 => _335.auditService]);
   }
   // ============================================================================
   // CACHE MANAGEMENT
@@ -14648,7 +15008,7 @@ var UserProfileService = class extends BaseService {
    */
   async deleteProfile(profileId, options) {
     const profile = await this.getProfileOrThrow(profileId);
-    if (_optionalChain([options, 'optionalAccess', _328 => _328.checkAdmin])) {
+    if (_optionalChain([options, 'optionalAccess', _336 => _336.checkAdmin])) {
       if (profile.role === "admin") {
         const adminCount = await this.adapter.userProfiles.countByRole("admin");
         if (adminCount <= 1) {
@@ -14723,7 +15083,7 @@ var UserProfileService = class extends BaseService {
    */
   async hasRole(profileId, role) {
     const profile = await this.getProfile(profileId);
-    return _optionalChain([profile, 'optionalAccess', _329 => _329.role]) === role;
+    return _optionalChain([profile, 'optionalAccess', _337 => _337.role]) === role;
   }
   /**
    * Check if user is admin
@@ -15157,7 +15517,7 @@ var DocumentTemplateService = class extends BaseService {
    * Includes both system templates and tenant-specific templates.
    */
   async listTemplates(options) {
-    if (_optionalChain([options, 'optionalAccess', _330 => _330.systemOnly])) {
+    if (_optionalChain([options, 'optionalAccess', _338 => _338.systemOnly])) {
       return SYSTEM_TEMPLATES;
     }
     const templates = [...SYSTEM_TEMPLATES];
@@ -15240,8 +15600,8 @@ var DocumentTemplateService = class extends BaseService {
 var DocumentService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
-    this.templateService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _331 => _331.templateService]), () => ( new DocumentTemplateService(adapter)));
-    this.fileService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _332 => _332.fileService]), () => ( null));
+    this.templateService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _339 => _339.templateService]), () => ( new DocumentTemplateService(adapter)));
+    this.fileService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _340 => _340.fileService]), () => ( null));
   }
   // ============================================================================
   // CREATE
@@ -15492,7 +15852,7 @@ var DocumentService = class extends BaseService {
    */
   async isComplete(documentId) {
     const document2 = await this.getDocument(documentId);
-    return _optionalChain([document2, 'optionalAccess', _333 => _333.status]) !== "draft";
+    return _optionalChain([document2, 'optionalAccess', _341 => _341.status]) !== "draft";
   }
   /**
    * Get document with its template and slots.
@@ -15750,7 +16110,7 @@ var DocumentProcessingService = class extends BaseService {
       type: "signature",
       provider: this.config.signatureAdapter.name,
       input: { signers, ...options },
-      expiresAt: _optionalChain([options, 'optionalAccess', _334 => _334.expiresAt])
+      expiresAt: _optionalChain([options, 'optionalAccess', _342 => _342.expiresAt])
     });
     return job;
   }
@@ -15907,7 +16267,7 @@ var DocumentProcessingService = class extends BaseService {
     }
     const document2 = await this.documentService.getDocumentOrThrow(documentId);
     const template = await this.templateService.getTemplateOrThrow(document2.templateId);
-    if (!_optionalChain([template, 'access', _335 => _335.autoProcessing, 'optionalAccess', _336 => _336.identityVerification, 'optionalAccess', _337 => _337.enabled])) {
+    if (!_optionalChain([template, 'access', _343 => _343.autoProcessing, 'optionalAccess', _344 => _344.identityVerification, 'optionalAccess', _345 => _345.enabled])) {
       throw new Error("Identity verification is not enabled for this document type");
     }
     const job = await this.adapter.documentJobs.create({
@@ -15993,13 +16353,13 @@ var DocumentProcessingService = class extends BaseService {
     const template = await this.templateService.getTemplateOrThrow(document2.templateId);
     const slots = await this.documentService.getSlots(documentId);
     const jobs = [];
-    if (_optionalChain([template, 'access', _338 => _338.autoProcessing, 'optionalAccess', _339 => _339.ocr, 'optionalAccess', _340 => _340.enabled]) && this.config.ocrAdapter) {
+    if (_optionalChain([template, 'access', _346 => _346.autoProcessing, 'optionalAccess', _347 => _347.ocr, 'optionalAccess', _348 => _348.enabled]) && this.config.ocrAdapter) {
       for (const slot of slots) {
         const job = await this.processOcr(documentId, slot.slotName);
         jobs.push(job);
       }
     }
-    if (_optionalChain([template, 'access', _341 => _341.autoProcessing, 'optionalAccess', _342 => _342.identityVerification, 'optionalAccess', _343 => _343.enabled]) && this.config.identityAdapter) {
+    if (_optionalChain([template, 'access', _349 => _349.autoProcessing, 'optionalAccess', _350 => _350.identityVerification, 'optionalAccess', _351 => _351.enabled]) && this.config.identityAdapter) {
       const job = await this.verifyIdentity(documentId);
       jobs.push(job);
     }
@@ -16070,15 +16430,15 @@ var DocumentProcessingService = class extends BaseService {
     return {
       ocr: {
         available: !!this.config.ocrAdapter,
-        provider: _optionalChain([this, 'access', _344 => _344.config, 'access', _345 => _345.ocrAdapter, 'optionalAccess', _346 => _346.name])
+        provider: _optionalChain([this, 'access', _352 => _352.config, 'access', _353 => _353.ocrAdapter, 'optionalAccess', _354 => _354.name])
       },
       signature: {
         available: !!this.config.signatureAdapter,
-        provider: _optionalChain([this, 'access', _347 => _347.config, 'access', _348 => _348.signatureAdapter, 'optionalAccess', _349 => _349.name])
+        provider: _optionalChain([this, 'access', _355 => _355.config, 'access', _356 => _356.signatureAdapter, 'optionalAccess', _357 => _357.name])
       },
       identityVerification: {
         available: !!this.config.identityAdapter,
-        provider: _optionalChain([this, 'access', _350 => _350.config, 'access', _351 => _351.identityAdapter, 'optionalAccess', _352 => _352.name])
+        provider: _optionalChain([this, 'access', _358 => _358.config, 'access', _359 => _359.identityAdapter, 'optionalAccess', _360 => _360.name])
       }
     };
   }
@@ -16088,7 +16448,7 @@ var DocumentProcessingService = class extends BaseService {
 var FileService = class extends BaseService {
   constructor(adapter, options) {
     super(adapter);
-    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _353 => _353.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
+    this.auditService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _361 => _361.auditService]), () => ( (adapter.audit ? new AuditService(adapter) : void 0)));
   }
   // ============================================================================
   // UPLOAD (requires StorageAdapter)
@@ -16227,7 +16587,7 @@ var FileService = class extends BaseService {
    */
   async getFile(fileId) {
     const file2 = await this.adapter.files.findById(fileId);
-    if (_optionalChain([file2, 'optionalAccess', _354 => _354.deletedAt])) {
+    if (_optionalChain([file2, 'optionalAccess', _362 => _362.deletedAt])) {
       return null;
     }
     return file2;
@@ -16289,12 +16649,12 @@ var FileService = class extends BaseService {
    */
   async deleteFile(fileId, options) {
     const file2 = await this.getFileOrThrow(fileId);
-    if (_optionalChain([options, 'optionalAccess', _355 => _355.checkOwnership]) && options.userId) {
+    if (_optionalChain([options, 'optionalAccess', _363 => _363.checkOwnership]) && options.userId) {
       if (file2.uploadedBy !== options.userId) {
         throw new Error("You can only delete files you uploaded");
       }
     }
-    if (_optionalChain([options, 'optionalAccess', _356 => _356.hard])) {
+    if (_optionalChain([options, 'optionalAccess', _364 => _364.hard])) {
       await this.adapter.files.hardDelete(fileId);
     } else {
       await this.adapter.files.delete(fileId);
@@ -16325,7 +16685,7 @@ var FileService = class extends BaseService {
     }
     const file2 = await this.getFileOrThrow(fileId);
     await this.adapter.storage.delete(file2.storagePath);
-    if (_optionalChain([options, 'optionalAccess', _357 => _357.hard])) {
+    if (_optionalChain([options, 'optionalAccess', _365 => _365.hard])) {
       await this.adapter.files.hardDelete(fileId);
     } else {
       await this.adapter.files.delete(fileId);
@@ -16351,15 +16711,15 @@ var FileService = class extends BaseService {
     const fileResults = await Promise.all(fileIds.map((id) => this.getFile(id)));
     const files = fileResults.filter((f) => f !== null);
     if (files.length === 0) return;
-    if (_optionalChain([options, 'optionalAccess', _358 => _358.deleteFromStorage]) && this.adapter.storage) {
+    if (_optionalChain([options, 'optionalAccess', _366 => _366.deleteFromStorage]) && this.adapter.storage) {
       const BATCH_SIZE = 10;
       for (let i = 0; i < files.length; i += BATCH_SIZE) {
         const batch = files.slice(i, i + BATCH_SIZE);
-        await Promise.all(batch.map((file2) => _optionalChain([this, 'access', _359 => _359.adapter, 'access', _360 => _360.storage, 'optionalAccess', _361 => _361.delete, 'call', _362 => _362(file2.storagePath)])));
+        await Promise.all(batch.map((file2) => _optionalChain([this, 'access', _367 => _367.adapter, 'access', _368 => _368.storage, 'optionalAccess', _369 => _369.delete, 'call', _370 => _370(file2.storagePath)])));
       }
     }
     const idsToDelete = files.map((f) => f.id);
-    if (_optionalChain([options, 'optionalAccess', _363 => _363.hard])) {
+    if (_optionalChain([options, 'optionalAccess', _371 => _371.hard])) {
       await Promise.all(idsToDelete.map((id) => this.adapter.files.hardDelete(id)));
     } else {
       await Promise.all(idsToDelete.map((id) => this.adapter.files.delete(id)));
@@ -16367,12 +16727,12 @@ var FileService = class extends BaseService {
     if (this.auditService && this.userId) {
       await Promise.all(
         files.map(
-          (file2) => _optionalChain([this, 'access', _364 => _364.auditService, 'optionalAccess', _365 => _365.logFileAction, 'call', _366 => _366({
+          (file2) => _optionalChain([this, 'access', _372 => _372.auditService, 'optionalAccess', _373 => _373.logFileAction, 'call', _374 => _374({
             action: "file.deleted",
             actorId: _nullishCoalesce(this.userId, () => ( "")),
             fileId: file2.id,
             fileName: file2.name,
-            metadata: { deletedFromStorage: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _367 => _367.deleteFromStorage]), () => ( false)) }
+            metadata: { deletedFromStorage: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _375 => _375.deleteFromStorage]), () => ( false)) }
           })])
         )
       );
@@ -16450,7 +16810,7 @@ var FileService = class extends BaseService {
     if (!file2) {
       return false;
     }
-    if (_optionalChain([options, 'optionalAccess', _368 => _368.isAdmin])) {
+    if (_optionalChain([options, 'optionalAccess', _376 => _376.isAdmin])) {
       return true;
     }
     if (file2.visibility === "public") {
@@ -16460,7 +16820,7 @@ var FileService = class extends BaseService {
       return true;
     }
     if (file2.visibility === "restricted") {
-      return _nullishCoalesce(_optionalChain([file2, 'access', _369 => _369.allowedUsers, 'optionalAccess', _370 => _370.includes, 'call', _371 => _371(userId)]), () => ( false));
+      return _nullishCoalesce(_optionalChain([file2, 'access', _377 => _377.allowedUsers, 'optionalAccess', _378 => _378.includes, 'call', _379 => _379(userId)]), () => ( false));
     }
     return false;
   }
@@ -16555,7 +16915,7 @@ function withTimeout(promise, ms, label) {
 var GeocodingService = class {
   constructor(adapter, options) {
     this.adapter = adapter;
-    this.timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _372 => _372.timeoutMs]), () => ( GEOCODING_TIMEOUT_MS));
+    this.timeoutMs = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _380 => _380.timeoutMs]), () => ( GEOCODING_TIMEOUT_MS));
   }
   /**
    * Search for address suggestions as the user types
@@ -16615,9 +16975,9 @@ var GlobalSearchService = class extends BaseService {
       "search",
       { query: query.trim(), ...options },
       () => this.adapter.objectRecords.globalSearch(query.trim(), {
-        limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _373 => _373.limit]), () => ( 20)),
-        offset: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _374 => _374.offset]), () => ( 0)),
-        objectNames: _optionalChain([options, 'optionalAccess', _375 => _375.objectNames])
+        limit: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _381 => _381.limit]), () => ( 20)),
+        offset: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _382 => _382.offset]), () => ( 0)),
+        objectNames: _optionalChain([options, 'optionalAccess', _383 => _383.objectNames])
       })
     );
   }
@@ -16638,8 +16998,8 @@ var GlobalSearchService = class extends BaseService {
       "grouped",
       { query: query.trim(), ...options },
       () => this.adapter.objectRecords.globalSearchGrouped(query.trim(), {
-        objectNames: _optionalChain([options, 'optionalAccess', _376 => _376.objectNames]),
-        limitPerGroup: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _377 => _377.limitPerGroup]), () => ( 5))
+        objectNames: _optionalChain([options, 'optionalAccess', _384 => _384.objectNames]),
+        limitPerGroup: _nullishCoalesce(_optionalChain([options, 'optionalAccess', _385 => _385.limitPerGroup]), () => ( 5))
       })
     );
   }
@@ -16656,7 +17016,7 @@ var PermissionService = class extends BaseService {
     }
     this.permissionsRepo = adapter.permissions;
     this.permissionCache = _nullishCoalesce(adapter.cache, () => ( new NoopCacheAdapter()));
-    this.auditService = _optionalChain([options, 'optionalAccess', _378 => _378.auditService]);
+    this.auditService = _optionalChain([options, 'optionalAccess', _386 => _386.auditService]);
   }
   // ============================================================================
   // PERMISSION CHECKS
@@ -16675,11 +17035,11 @@ var PermissionService = class extends BaseService {
       return true;
     }
     const wildcardPerms = permissions.objectPermissions["*"];
-    if (_optionalChain([wildcardPerms, 'optionalAccess', _379 => _379.includes, 'call', _380 => _380(action)])) {
+    if (_optionalChain([wildcardPerms, 'optionalAccess', _387 => _387.includes, 'call', _388 => _388(action)])) {
       return true;
     }
     const objectPerms = permissions.objectPermissions[objectName];
-    return _nullishCoalesce(_optionalChain([objectPerms, 'optionalAccess', _381 => _381.includes, 'call', _382 => _382(action)]), () => ( false));
+    return _nullishCoalesce(_optionalChain([objectPerms, 'optionalAccess', _389 => _389.includes, 'call', _390 => _390(action)]), () => ( false));
   }
   /**
    * Check if user can access an object, throw ForbiddenError if not.
@@ -16734,12 +17094,12 @@ var PermissionService = class extends BaseService {
     if (permissions.isAdmin) {
       return true;
     }
-    const wildcardPerms = _optionalChain([permissions, 'access', _383 => _383.systemPermissions, 'optionalAccess', _384 => _384["*"]]);
-    if (_optionalChain([wildcardPerms, 'optionalAccess', _385 => _385.includes, 'call', _386 => _386(action)])) {
+    const wildcardPerms = _optionalChain([permissions, 'access', _391 => _391.systemPermissions, 'optionalAccess', _392 => _392["*"]]);
+    if (_optionalChain([wildcardPerms, 'optionalAccess', _393 => _393.includes, 'call', _394 => _394(action)])) {
       return true;
     }
-    const resourcePerms = _optionalChain([permissions, 'access', _387 => _387.systemPermissions, 'optionalAccess', _388 => _388[resource]]);
-    return _nullishCoalesce(_optionalChain([resourcePerms, 'optionalAccess', _389 => _389.includes, 'call', _390 => _390(action)]), () => ( false));
+    const resourcePerms = _optionalChain([permissions, 'access', _395 => _395.systemPermissions, 'optionalAccess', _396 => _396[resource]]);
+    return _nullishCoalesce(_optionalChain([resourcePerms, 'optionalAccess', _397 => _397.includes, 'call', _398 => _398(action)]), () => ( false));
   }
   /**
    * Check if user can access a system resource, throw ForbiddenError if not.
@@ -16768,8 +17128,8 @@ var PermissionService = class extends BaseService {
     if (permissions.isAdmin) {
       return { canRead: true, canCreate: true, canUpdate: true, canDelete: true };
     }
-    const wildcardPerms = _nullishCoalesce(_optionalChain([permissions, 'access', _391 => _391.systemPermissions, 'optionalAccess', _392 => _392["*"]]), () => ( []));
-    const resourcePerms = _nullishCoalesce(_optionalChain([permissions, 'access', _393 => _393.systemPermissions, 'optionalAccess', _394 => _394[resource]]), () => ( []));
+    const wildcardPerms = _nullishCoalesce(_optionalChain([permissions, 'access', _399 => _399.systemPermissions, 'optionalAccess', _400 => _400["*"]]), () => ( []));
+    const resourcePerms = _nullishCoalesce(_optionalChain([permissions, 'access', _401 => _401.systemPermissions, 'optionalAccess', _402 => _402[resource]]), () => ( []));
     const allPerms = /* @__PURE__ */ new Set([...wildcardPerms, ...resourcePerms]);
     return {
       canRead: allPerms.has("read"),
@@ -16912,7 +17272,7 @@ var PermissionService = class extends BaseService {
         action: "role.updated",
         actorId: this.userId,
         roleId,
-        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _395 => _395.label]), () => ( roleId)),
+        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _403 => _403.label]), () => ( roleId)),
         metadata: { permissionsUpdated: true, permissionCount: permissions.length }
       });
     }
@@ -16942,7 +17302,7 @@ var PermissionService = class extends BaseService {
         action: "role.assigned",
         actorId: this.userId,
         roleId,
-        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _396 => _396.label]), () => ( roleId)),
+        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _404 => _404.label]), () => ( roleId)),
         targetUserId: userProfileId
       });
     }
@@ -16960,7 +17320,7 @@ var PermissionService = class extends BaseService {
         action: "role.revoked",
         actorId: this.userId,
         roleId,
-        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _397 => _397.label]), () => ( roleId)),
+        roleLabel: _nullishCoalesce(_optionalChain([role, 'optionalAccess', _405 => _405.label]), () => ( roleId)),
         targetUserId: userProfileId
       });
     }
@@ -17259,14 +17619,6 @@ var ViewService = class extends BaseService {
       type: "activity",
       order: 1
     });
-    tabs.push({
-      id: "notes",
-      name: "notes",
-      label: "Notes",
-      type: "notes",
-      order: 2,
-      allowCreate: true
-    });
     const hasDocuments = object2.attributes.some((attr) => attr.type === "document");
     if (hasDocuments) {
       tabs.push({
@@ -17443,7 +17795,7 @@ var ViewService = class extends BaseService {
       dbView.objectName,
       dbView.type,
       objectDefinition,
-      dbView.type === "detail" ? _nullishCoalesce(_optionalChain([dbView, 'access', _398 => _398.config, 'optionalAccess', _399 => _399.layout]), () => ( "page")) : void 0
+      dbView.type === "detail" ? _nullishCoalesce(_optionalChain([dbView, 'access', _406 => _406.config, 'optionalAccess', _407 => _407.layout]), () => ( "page")) : void 0
     );
     const newConfig = generated.config;
     const updated = await this.adapter.views.update(viewId, { config: newConfig });
@@ -18314,18 +18666,4 @@ var NoopGeocodingAdapter = class {
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.IDENTITY_PROPERTIES = IDENTITY_PROPERTIES; exports.BEHAVIOR_PROPERTIES = BEHAVIOR_PROPERTIES; exports.PRESENTATION_PROPERTIES = PRESENTATION_PROPERTIES; exports.isIdentityProperty = isIdentityProperty; exports.isBehaviorProperty = isBehaviorProperty; exports.isPresentationProperty = isPresentationProperty; exports.RELATION_TARGET_ANY = RELATION_TARGET_ANY; exports.isUniversalRelation = isUniversalRelation; exports.RecordReferencedError = RecordReferencedError; exports.AttributeInUseError = AttributeInUseError; exports.ObjectReferencedError = ObjectReferencedError; exports.getErrorMessage = getErrorMessage; exports.NoopGeocodingAdapter = NoopGeocodingAdapter; exports.SYSTEM_FIELD_NAMES = SYSTEM_FIELD_NAMES; exports.RESERVED_ATTRIBUTE_NAMES = RESERVED_ATTRIBUTE_NAMES; exports.PolicyViolationError = PolicyViolationError; exports.FORBIDDEN_PROPERTY_TYPES = FORBIDDEN_PROPERTY_TYPES; exports.SYSTEM_ATTRIBUTES = SYSTEM_ATTRIBUTES; exports.getSystemAttributeList = getSystemAttributeList; exports.isSystemAttribute = isSystemAttribute; exports.isSystemAttributeObject = isSystemAttributeObject; exports.isSimpleFormNode = isSimpleFormNode; exports.isAdvancedFormNode = isAdvancedFormNode; exports.isStartNode = isStartNode; exports.isFormNode = isFormNode; exports.isConditionNode = isConditionNode; exports.isDocumentNode = isDocumentNode; exports.isEndNode = isEndNode; exports.getNodeOutputs = getNodeOutputs; exports.isConditionRule = isConditionRule; exports.isConditionGroup = isConditionGroup; exports.eq = eq; exports.neq = neq; exports.and = and; exports.or = or; exports.inValues = inValues; exports.isWorkflowDefinition = isWorkflowDefinition; exports.isWorkflowPublished = isWorkflowPublished; exports.isSystemWorkflow = isSystemWorkflow; exports.isInstanceTerminal = isInstanceTerminal; exports.isInstanceWaiting = isInstanceWaiting; exports.canResumeInstance = canResumeInstance; exports.createStartTransition = createStartTransition; exports.isInvitationValid = isInvitationValid; exports.isInvitationAccepted = isInvitationAccepted; exports.isInvitationExpired = isInvitationExpired; exports.isGrantValid = isGrantValid; exports.isGrantRevoked = isGrantRevoked; exports.isTokenRevoked = isTokenRevoked; exports.isGrantExpired = isGrantExpired; exports.canAccessNode = canAccessNode; exports.createEmptyContext = createEmptyContext; exports.getContextValue = getContextValue; exports.setContextValue = setContextValue; exports.DEFAULT_THEME = DEFAULT_THEME; exports.mergeWithDefaults = mergeWithDefaults; exports.generateCssVariables = generateCssVariables; exports.isInstanceEvent = isInstanceEvent; exports.isNodeEvent = isNodeEvent; exports.isInvitationOrGrantEvent = isInvitationOrGrantEvent; exports.ConditionOperatorSchema = ConditionOperatorSchema; exports.ConditionRuleSchema = ConditionRuleSchema; exports.ConditionGroupSchema = ConditionGroupSchema; exports.StartNodeSchema = StartNodeSchema; exports.FormFieldRefSchema = FormFieldRefSchema; exports.FlowRowFieldSchema = FlowRowFieldSchema; exports.FlowRowSchema = FlowRowSchema; exports.FormNodeSchema = FormNodeSchema; exports.ConditionNodeSchema = ConditionNodeSchema; exports.DocumentNodeSchema = DocumentNodeSchema; exports.EndNodeSchema = EndNodeSchema; exports.WorkflowNodeSchema = WorkflowNodeSchema; exports.SlotModeSchema = SlotModeSchema; exports.WorkflowSlotSchema = WorkflowSlotSchema; exports.AuthMethodSchema = AuthMethodSchema; exports.ShareStatusSchema = ShareStatusSchema; exports.WorkflowShareSchema = WorkflowShareSchema; exports.CreateShareInputSchema = CreateShareInputSchema; exports.NodePositionSchema = NodePositionSchema; exports.ViewportSchema = ViewportSchema; exports.WorkflowLayoutSchema = WorkflowLayoutSchema; exports.ThemeColorsSchema = ThemeColorsSchema; exports.ThemeLogoSchema = ThemeLogoSchema; exports.WorkflowThemeSchema = WorkflowThemeSchema; exports.WorkflowConfigSchema = WorkflowConfigSchema; exports.WorkflowStatusSchema = WorkflowStatusSchema; exports.WorkflowDefinitionSchema = WorkflowDefinitionSchema; exports.isEmpty = isEmpty; exports.isNotEmpty = isNotEmpty; exports.toUndefinedIfEmpty = toUndefinedIfEmpty; exports.hasProperties = hasProperties; exports.EMPTY_VALUE_PLACEHOLDER = EMPTY_VALUE_PLACEHOLDER; exports.formatAttributeValue = formatAttributeValue; exports.SchemaErrorCode = SchemaErrorCode; exports.SchemaError = SchemaError; exports.NotFoundError = NotFoundError; exports.ObjectNotFoundError = ObjectNotFoundError; exports.AttributeNotFoundError = AttributeNotFoundError; exports.RecordNotFoundError = RecordNotFoundError; exports.UserProfileNotFoundError = UserProfileNotFoundError; exports.FileNotFoundError = FileNotFoundError; exports.ValidationError = ValidationError; exports.ProtectedResourceError = ProtectedResourceError; exports.SyncError = SyncError; exports.NotSystemObjectError = NotSystemObjectError; exports.DuplicateError = DuplicateError; exports.isSchemaError = isSchemaError; exports.isNotFoundError = isNotFoundError; exports.isValidationError = isValidationError; exports.isProtectedResourceError = isProtectedResourceError; exports.ForbiddenError = ForbiddenError; exports.ProtectedRoleError = ProtectedRoleError; exports.RoleNotFoundError = RoleNotFoundError; exports.isForbiddenError = isForbiddenError; exports.ConcurrentModificationError = ConcurrentModificationError; exports.PropertySchemaBuilder = PropertySchemaBuilder; exports.PropertyTypeBuilder = PropertyTypeBuilder; exports.BasePropertyBuilder = BasePropertyBuilder; exports.TextPropertyBuilder = TextPropertyBuilder; exports.TextareaPropertyBuilder = TextareaPropertyBuilder; exports.NumberPropertyBuilder = NumberPropertyBuilder; exports.CheckboxPropertyBuilder = CheckboxPropertyBuilder; exports.DatePropertyBuilder = DatePropertyBuilder; exports.PhonePropertyBuilder = PhonePropertyBuilder; exports.CurrencyPropertyBuilder = CurrencyPropertyBuilder; exports.StatusPropertyBuilder = StatusPropertyBuilder; exports.SelectPropertyBuilder = SelectPropertyBuilder; exports.MultiselectPropertyBuilder = MultiselectPropertyBuilder; exports.RatingPropertyBuilder = RatingPropertyBuilder; exports.LocationPropertyBuilder = LocationPropertyBuilder; exports.validatePropertyType = validatePropertyType; exports.text = text; exports.textarea = textarea; exports.richtext = richtext; exports.number = number; exports.checkbox = checkbox; exports.date = date; exports.phone = phone; exports.currency = currency; exports.status = status; exports.select = select; exports.multiselect = multiselect; exports.location = location; exports.file = file; exports.user = user; exports.relation = relation; exports.rating = rating; exports.formula = formula; exports.rollup = rollup; exports.document = document; exports.ObjectBuilder = ObjectBuilder; exports.object = object; exports.GroupBuilder = GroupBuilder; exports.DirectTableTabConfig = DirectTableTabConfig; exports.InverseTableTabConfig = InverseTableTabConfig; exports.CustomTabConfig = CustomTabConfig; exports.NotesTabConfig = NotesTabConfig; exports.ActivityTabConfig = ActivityTabConfig; exports.FlowsTabConfig = FlowsTabConfig; exports.DocumentsTabConfig = DocumentsTabConfig; exports.TabBuilder = TabBuilder; exports.DetailViewBuilder = DetailViewBuilder; exports.ViewBuilder = ViewBuilder; exports.detailView = detailView; exports.view = view; exports.ListViewBuilder = ListViewBuilder; exports.ListViewTabConfigBuilder = ListViewTabConfigBuilder; exports.listView = listView; exports.group = group; exports.WorkflowFormRowBuilder = WorkflowFormRowBuilder; exports.WorkflowFormBuilder = WorkflowFormBuilder; exports.WorkflowSimpleFormBuilder = WorkflowSimpleFormBuilder; exports.WorkflowConditionBuilder = WorkflowConditionBuilder; exports.WorkflowEndBuilder = WorkflowEndBuilder; exports.WorkflowStartBuilder = WorkflowStartBuilder; exports.WorkflowBuilder = WorkflowBuilder; exports.workflow = workflow; exports.registry = registry; exports.SYSTEM_TEMPLATE_IDS = SYSTEM_TEMPLATE_IDS; exports.FRENCH_ID_CARD = FRENCH_ID_CARD; exports.PASSPORT = PASSPORT; exports.DRIVING_LICENSE = DRIVING_LICENSE; exports.PROOF_OF_ADDRESS = PROOF_OF_ADDRESS; exports.SIGNABLE_CONTRACT = SIGNABLE_CONTRACT; exports.GENERIC_DOCUMENT = GENERIC_DOCUMENT; exports.SYSTEM_TEMPLATES = SYSTEM_TEMPLATES; exports.getSystemTemplate = getSystemTemplate; exports.isSystemTemplate = isSystemTemplate; exports.WorkflowJwtService = WorkflowJwtService; exports.hashOptions = hashOptions; exports.cacheKeys = cacheKeys; exports.cacheTtl = cacheTtl; exports.defaultTtl = defaultTtl; exports.NoopCacheAdapter = NoopCacheAdapter; exports.formatRecord = formatRecord; exports.formatRecords = formatRecords; exports.createDefaultState = createDefaultState; exports.SHORTCUT_TO_FILTER_OPERATOR = SHORTCUT_TO_FILTER_OPERATOR; exports.QueryNoResultError = QueryNoResultError; exports.QueryMultipleResultsError = QueryMultipleResultsError; exports.TenantContextError = TenantContextError; exports.FeatureFlagsContextError = FeatureFlagsContextError; exports.isFeatureEnabled = isFeatureEnabled; exports.getFeatureValue = getFeatureValue; exports.getFeatureFlags = getFeatureFlags; exports.tryGetFeatureValue = tryGetFeatureValue; exports.hasFeatureFlagsContext = hasFeatureFlagsContext; exports.runWithFeatureFlags = runWithFeatureFlags; exports.withFeatureFlags = withFeatureFlags; exports.getSchemaFromContext = getSchemaFromContext; exports.getSchemaByNameFromContext = getSchemaByNameFromContext; exports.hasSchemaContext = hasSchemaContext; exports.getSchemaContext = getSchemaContext; exports.addSchemaToContext = addSchemaToContext; exports.runWithSchemaContext = runWithSchemaContext; exports.runWithMergedSchemaContext = runWithMergedSchemaContext; exports.getContext = getContext2; exports.getTenantId = getTenantId; exports.getUserId = getUserId; exports.hasContext = hasContext; exports.runWithContext = runWithContext; exports.withTenantContext = withTenantContext; exports.QueryBuilder = QueryBuilder; exports.createQueryBuilder = createQueryBuilder; exports.evaluateCondition = evaluateCondition; exports.evaluate = evaluate; exports.evaluateWithTrace = evaluateWithTrace; exports.ExecutorRegistry = ExecutorRegistry; exports.success = success; exports.wait = wait; exports.complete = complete; exports.error = error; exports.ConditionExecutor = ConditionExecutor; exports.DocumentExecutor = DocumentExecutor; exports.EndExecutor = EndExecutor; exports.FormExecutor = FormExecutor; exports.StartExecutor = StartExecutor; exports.createDefaultExecutorRegistry = createDefaultExecutorRegistry; exports.getDefaultExecutorRegistry = getDefaultExecutorRegistry; exports.evaluateFormula = evaluateFormula; exports.evaluateFormulaWithResult = evaluateFormulaWithResult; exports.formatFormulaResult = formatFormulaResult; exports.evaluateFormulaAttribute = evaluateFormulaAttribute; exports.validateFormulaExpression = validateFormulaExpression; exports.extractFormulaVariables = extractFormulaVariables; exports.extractRelationReferences = extractRelationReferences; exports.extractRelationNames = extractRelationNames; exports.hasRelationReferences = hasRelationReferences; exports.flattenRelationsForEval = flattenRelationsForEval; exports.evaluateFormulaWithRelations = evaluateFormulaWithRelations; exports.evaluateFormulaAttributeWithRelations = evaluateFormulaAttributeWithRelations; exports.InvalidPathError = InvalidPathError; exports.MaxDepthExceededError = MaxDepthExceededError; exports.parsePath = parsePath; exports.validatePath = validatePath; exports.pathHasManyCardinality = pathHasManyCardinality; exports.getPathDepth = getPathDepth; exports.getTargetAttributeName = getTargetAttributeName; exports.getRelationPath = getRelationPath; exports.traversePath = traversePath; exports.resolveSingleValue = resolveSingleValue; exports.resolveMultiplePaths = resolveMultiplePaths; exports.NoopHookRegistry = NoopHookRegistry; exports.DEFAULT_LABEL_FALLBACK = DEFAULT_LABEL_FALLBACK; exports.renderLabelExpression = renderLabelExpression; exports.isLabelExpression = isLabelExpression; exports.extractAttributeNames = extractAttributeNames; exports.enrichValuesForDisplay = enrichValuesForDisplay; exports.enrichValuesWithSelectLabels = enrichValuesWithSelectLabels; exports.extractRelationIds = extractRelationIds; exports.computeLabelWithRelations = computeLabelWithRelations; exports.createMockAdapter = createMockAdapter; exports.PolicyRegistry = PolicyRegistry; exports.defaultPolicyRegistry = defaultPolicyRegistry; exports.notesPolicy = notesPolicy; exports.BaseService = BaseService; exports.BaseRepository = BaseRepository; exports.SchemaContextAwareRepository = SchemaContextAwareRepository; exports.buildAuditChanges = buildAuditChanges; exports.ObjectSchemaService = ObjectSchemaService; exports.AuditService = AuditService; exports.UserService = UserService; exports.applyDefaultValues = applyDefaultValues; exports.checkPermission = checkPermission; exports.getPolicy = getPolicy; exports.buildPolicyContext = buildPolicyContext; exports.checkRecordAccess = checkRecordAccess; exports.checkRecordModifyOrThrow = checkRecordModifyOrThrow; exports.checkRecordDeleteOrThrow = checkRecordDeleteOrThrow; exports.checkSharedObjectWriteAccess = checkSharedObjectWriteAccess; exports.computeLabel = computeLabel; exports.enrichWithFormulas = enrichWithFormulas; exports.enrichRecordsWithFormulas = enrichRecordsWithFormulas; exports.createContextForCreate = createContextForCreate; exports.createContextForUpdate = createContextForUpdate; exports.createContextForDelete = createContextForDelete; exports.createContextForRestore = createContextForRestore; exports.recalculateParentRollups = recalculateParentRollups; exports.RecordQueryService = RecordQueryService; exports.RecordResolverService = RecordResolverService; exports.RelationPropertiesService = RelationPropertiesService; exports.RelationService = RelationService; exports.RollupService = RollupService; exports.RecordService = RecordService; exports.FormulaResolverService = FormulaResolverService; exports.RollupScheduler = RollupScheduler; exports.DocumentRenderError = DocumentRenderError; exports.StorageDownloadNotSupportedError = StorageDownloadNotSupportedError; exports.DocumentRendererService = DocumentRendererService; exports.DocumentProcessingHook = DocumentProcessingHook; exports.GrantNotFoundError = GrantNotFoundError; exports.GrantExpiredError = GrantExpiredError; exports.GrantRevokedError = GrantRevokedError; exports.TokenRevokedError = TokenRevokedError; exports.WorkflowAccessGrantService = WorkflowAccessGrantService; exports.WorkflowInstanceService = WorkflowInstanceService; exports.InvitationNotFoundError = InvitationNotFoundError; exports.InvitationExpiredError = InvitationExpiredError; exports.InvitationAlreadyAcceptedError = InvitationAlreadyAcceptedError; exports.InvitationRevokedError = InvitationRevokedError; exports.WorkflowInvitationService = WorkflowInvitationService; exports.WorkflowRelationService = WorkflowRelationService; exports.WorkflowService = WorkflowService; exports.UserProfileService = UserProfileService; exports.DocumentGenerationTemplateNotFoundError = DocumentGenerationTemplateNotFoundError; exports.DocumentGenerationNotConfiguredError = DocumentGenerationNotConfiguredError; exports.DocumentGenerationService = DocumentGenerationService; exports.DocumentTemplateService = DocumentTemplateService; exports.DocumentService = DocumentService; exports.DocumentProcessingService = DocumentProcessingService; exports.FileService = FileService; exports.GeocodingService = GeocodingService; exports.GlobalSearchService = GlobalSearchService; exports.PermissionService = PermissionService; exports.ViewService = ViewService; exports.seedRegistryViews = seedRegistryViews; exports.syncNativeViews = syncNativeViews; exports.verifyRegistryViewsSeeded = verifyRegistryViewsSeeded; exports.verifyNativeViewsSync = verifyNativeViewsSync; exports.getViewSeedPreview = getViewSeedPreview; exports.getViewSyncPreview = getViewSyncPreview; exports.syncNativeObjects = syncNativeObjects; exports.verifyNativeObjectsSync = verifyNativeObjectsSync; exports.getSyncPreview = getSyncPreview; exports.syncAll = syncAll;
+exports.IDENTITY_PROPERTIES = IDENTITY_PROPERTIES; exports.BEHAVIOR_PROPERTIES = BEHAVIOR_PROPERTIES; exports.PRESENTATION_PROPERTIES = PRESENTATION_PROPERTIES; exports.isIdentityProperty = isIdentityProperty; exports.isBehaviorProperty = isBehaviorProperty; exports.isPresentationProperty = isPresentationProperty; exports.RELATION_TARGET_ANY = RELATION_TARGET_ANY; exports.isUniversalRelation = isUniversalRelation; exports.isBilateralRelation = isBilateralRelation; exports.inferInverseCardinality = inferInverseCardinality; exports.RecordReferencedError = RecordReferencedError; exports.AttributeInUseError = AttributeInUseError; exports.ObjectReferencedError = ObjectReferencedError; exports.getErrorMessage = getErrorMessage; exports.NoopGeocodingAdapter = NoopGeocodingAdapter; exports.SYSTEM_FIELD_NAMES = SYSTEM_FIELD_NAMES; exports.RESERVED_ATTRIBUTE_NAMES = RESERVED_ATTRIBUTE_NAMES; exports.PolicyViolationError = PolicyViolationError; exports.FORBIDDEN_PROPERTY_TYPES = FORBIDDEN_PROPERTY_TYPES; exports.SYSTEM_ATTRIBUTES = SYSTEM_ATTRIBUTES; exports.getSystemAttributeList = getSystemAttributeList; exports.isSystemAttribute = isSystemAttribute; exports.isSystemAttributeObject = isSystemAttributeObject; exports.isSimpleFormNode = isSimpleFormNode; exports.isAdvancedFormNode = isAdvancedFormNode; exports.isStartNode = isStartNode; exports.isFormNode = isFormNode; exports.isConditionNode = isConditionNode; exports.isDocumentNode = isDocumentNode; exports.isEndNode = isEndNode; exports.getNodeOutputs = getNodeOutputs; exports.isConditionRule = isConditionRule; exports.isConditionGroup = isConditionGroup; exports.eq = eq; exports.neq = neq; exports.and = and; exports.or = or; exports.inValues = inValues; exports.isWorkflowDefinition = isWorkflowDefinition; exports.isWorkflowPublished = isWorkflowPublished; exports.isSystemWorkflow = isSystemWorkflow; exports.isInstanceTerminal = isInstanceTerminal; exports.isInstanceWaiting = isInstanceWaiting; exports.canResumeInstance = canResumeInstance; exports.createStartTransition = createStartTransition; exports.isInvitationValid = isInvitationValid; exports.isInvitationAccepted = isInvitationAccepted; exports.isInvitationExpired = isInvitationExpired; exports.isGrantValid = isGrantValid; exports.isGrantRevoked = isGrantRevoked; exports.isTokenRevoked = isTokenRevoked; exports.isGrantExpired = isGrantExpired; exports.canAccessNode = canAccessNode; exports.createEmptyContext = createEmptyContext; exports.getContextValue = getContextValue; exports.setContextValue = setContextValue; exports.DEFAULT_THEME = DEFAULT_THEME; exports.mergeWithDefaults = mergeWithDefaults; exports.generateCssVariables = generateCssVariables; exports.isInstanceEvent = isInstanceEvent; exports.isNodeEvent = isNodeEvent; exports.isInvitationOrGrantEvent = isInvitationOrGrantEvent; exports.ConditionOperatorSchema = ConditionOperatorSchema; exports.ConditionRuleSchema = ConditionRuleSchema; exports.ConditionGroupSchema = ConditionGroupSchema; exports.StartNodeSchema = StartNodeSchema; exports.FormFieldRefSchema = FormFieldRefSchema; exports.FlowRowFieldSchema = FlowRowFieldSchema; exports.FlowRowSchema = FlowRowSchema; exports.FormNodeSchema = FormNodeSchema; exports.ConditionNodeSchema = ConditionNodeSchema; exports.DocumentNodeSchema = DocumentNodeSchema; exports.EndNodeSchema = EndNodeSchema; exports.WorkflowNodeSchema = WorkflowNodeSchema; exports.SlotModeSchema = SlotModeSchema; exports.WorkflowSlotSchema = WorkflowSlotSchema; exports.AuthMethodSchema = AuthMethodSchema; exports.ShareStatusSchema = ShareStatusSchema; exports.WorkflowShareSchema = WorkflowShareSchema; exports.CreateShareInputSchema = CreateShareInputSchema; exports.NodePositionSchema = NodePositionSchema; exports.ViewportSchema = ViewportSchema; exports.WorkflowLayoutSchema = WorkflowLayoutSchema; exports.ThemeColorsSchema = ThemeColorsSchema; exports.ThemeLogoSchema = ThemeLogoSchema; exports.WorkflowThemeSchema = WorkflowThemeSchema; exports.WorkflowConfigSchema = WorkflowConfigSchema; exports.WorkflowStatusSchema = WorkflowStatusSchema; exports.WorkflowDefinitionSchema = WorkflowDefinitionSchema; exports.isEmpty = isEmpty; exports.isNotEmpty = isNotEmpty; exports.toUndefinedIfEmpty = toUndefinedIfEmpty; exports.hasProperties = hasProperties; exports.EMPTY_VALUE_PLACEHOLDER = EMPTY_VALUE_PLACEHOLDER; exports.formatAttributeValue = formatAttributeValue; exports.DEFAULT_LABEL_FALLBACK = DEFAULT_LABEL_FALLBACK; exports.renderLabelExpression = renderLabelExpression; exports.isLabelExpression = isLabelExpression; exports.extractAttributeNames = extractAttributeNames; exports.enrichValuesForDisplay = enrichValuesForDisplay; exports.enrichValuesWithSelectLabels = enrichValuesWithSelectLabels; exports.extractRelationIds = extractRelationIds; exports.computeLabelWithRelations = computeLabelWithRelations; exports.SchemaErrorCode = SchemaErrorCode; exports.SchemaError = SchemaError; exports.NotFoundError = NotFoundError; exports.ObjectNotFoundError = ObjectNotFoundError; exports.AttributeNotFoundError = AttributeNotFoundError; exports.RecordNotFoundError = RecordNotFoundError; exports.UserProfileNotFoundError = UserProfileNotFoundError; exports.FileNotFoundError = FileNotFoundError; exports.ValidationError = ValidationError; exports.ProtectedResourceError = ProtectedResourceError; exports.SyncError = SyncError; exports.NotSystemObjectError = NotSystemObjectError; exports.DuplicateError = DuplicateError; exports.isSchemaError = isSchemaError; exports.isNotFoundError = isNotFoundError; exports.isValidationError = isValidationError; exports.isProtectedResourceError = isProtectedResourceError; exports.ForbiddenError = ForbiddenError; exports.ProtectedRoleError = ProtectedRoleError; exports.RoleNotFoundError = RoleNotFoundError; exports.isForbiddenError = isForbiddenError; exports.ConcurrentModificationError = ConcurrentModificationError; exports.text = text; exports.textarea = textarea; exports.richtext = richtext; exports.number = number; exports.checkbox = checkbox; exports.date = date; exports.phone = phone; exports.currency = currency; exports.status = status; exports.select = select; exports.multiselect = multiselect; exports.location = location; exports.file = file; exports.user = user; exports.relation = relation; exports.rating = rating; exports.formula = formula; exports.rollup = rollup; exports.document = document; exports.ObjectBuilder = ObjectBuilder; exports.object = object; exports.GroupBuilder = GroupBuilder; exports.RelationGroupBuilder = RelationGroupBuilder; exports.TableTabConfig = TableTabConfig; exports.CustomTabConfig = CustomTabConfig; exports.RichtextTabConfig = RichtextTabConfig; exports.ActivityTabConfig = ActivityTabConfig; exports.FlowsTabConfig = FlowsTabConfig; exports.DocumentsTabConfig = DocumentsTabConfig; exports.TabBuilder = TabBuilder; exports.DetailViewBuilder = DetailViewBuilder; exports.ViewBuilder = ViewBuilder; exports.detailView = detailView; exports.view = view; exports.ListViewBuilder = ListViewBuilder; exports.ListViewTabConfigBuilder = ListViewTabConfigBuilder; exports.listView = listView; exports.group = group; exports.relationGroup = relationGroup; exports.WorkflowFormRowBuilder = WorkflowFormRowBuilder; exports.WorkflowFormBuilder = WorkflowFormBuilder; exports.WorkflowSimpleFormBuilder = WorkflowSimpleFormBuilder; exports.WorkflowConditionBuilder = WorkflowConditionBuilder; exports.WorkflowEndBuilder = WorkflowEndBuilder; exports.WorkflowStartBuilder = WorkflowStartBuilder; exports.WorkflowBuilder = WorkflowBuilder; exports.workflow = workflow; exports.registry = registry; exports.SYSTEM_TEMPLATE_IDS = SYSTEM_TEMPLATE_IDS; exports.FRENCH_ID_CARD = FRENCH_ID_CARD; exports.PASSPORT = PASSPORT; exports.DRIVING_LICENSE = DRIVING_LICENSE; exports.PROOF_OF_ADDRESS = PROOF_OF_ADDRESS; exports.SIGNABLE_CONTRACT = SIGNABLE_CONTRACT; exports.GENERIC_DOCUMENT = GENERIC_DOCUMENT; exports.SYSTEM_TEMPLATES = SYSTEM_TEMPLATES; exports.getSystemTemplate = getSystemTemplate; exports.isSystemTemplate = isSystemTemplate; exports.WorkflowJwtService = WorkflowJwtService; exports.hashOptions = hashOptions; exports.cacheKeys = cacheKeys; exports.cacheTtl = cacheTtl; exports.defaultTtl = defaultTtl; exports.NoopCacheAdapter = NoopCacheAdapter; exports.formatRecord = formatRecord; exports.formatRecords = formatRecords; exports.createDefaultState = createDefaultState; exports.SHORTCUT_TO_FILTER_OPERATOR = SHORTCUT_TO_FILTER_OPERATOR; exports.QueryNoResultError = QueryNoResultError; exports.QueryMultipleResultsError = QueryMultipleResultsError; exports.TenantContextError = TenantContextError; exports.FeatureFlagsContextError = FeatureFlagsContextError; exports.isFeatureEnabled = isFeatureEnabled; exports.getFeatureValue = getFeatureValue; exports.getFeatureFlags = getFeatureFlags; exports.tryGetFeatureValue = tryGetFeatureValue; exports.hasFeatureFlagsContext = hasFeatureFlagsContext; exports.runWithFeatureFlags = runWithFeatureFlags; exports.withFeatureFlags = withFeatureFlags; exports.getSchemaFromContext = getSchemaFromContext; exports.getSchemaByNameFromContext = getSchemaByNameFromContext; exports.hasSchemaContext = hasSchemaContext; exports.getSchemaContext = getSchemaContext; exports.addSchemaToContext = addSchemaToContext; exports.runWithSchemaContext = runWithSchemaContext; exports.runWithMergedSchemaContext = runWithMergedSchemaContext; exports.getContext = getContext2; exports.getTenantId = getTenantId; exports.getUserId = getUserId; exports.hasContext = hasContext; exports.runWithContext = runWithContext; exports.withTenantContext = withTenantContext; exports.QueryBuilder = QueryBuilder; exports.createQueryBuilder = createQueryBuilder; exports.evaluateCondition = evaluateCondition; exports.evaluate = evaluate; exports.evaluateWithTrace = evaluateWithTrace; exports.ExecutorRegistry = ExecutorRegistry; exports.success = success; exports.wait = wait; exports.complete = complete; exports.error = error; exports.ConditionExecutor = ConditionExecutor; exports.DocumentExecutor = DocumentExecutor; exports.EndExecutor = EndExecutor; exports.FormExecutor = FormExecutor; exports.StartExecutor = StartExecutor; exports.createDefaultExecutorRegistry = createDefaultExecutorRegistry; exports.getDefaultExecutorRegistry = getDefaultExecutorRegistry; exports.evaluateFormula = evaluateFormula; exports.evaluateFormulaWithResult = evaluateFormulaWithResult; exports.formatFormulaResult = formatFormulaResult; exports.evaluateFormulaAttribute = evaluateFormulaAttribute; exports.validateFormulaExpression = validateFormulaExpression; exports.extractFormulaVariables = extractFormulaVariables; exports.extractRelationReferences = extractRelationReferences; exports.extractRelationNames = extractRelationNames; exports.hasRelationReferences = hasRelationReferences; exports.flattenRelationsForEval = flattenRelationsForEval; exports.evaluateFormulaWithRelations = evaluateFormulaWithRelations; exports.evaluateFormulaAttributeWithRelations = evaluateFormulaAttributeWithRelations; exports.InvalidPathError = InvalidPathError; exports.MaxDepthExceededError = MaxDepthExceededError; exports.parsePath = parsePath; exports.validatePath = validatePath; exports.pathHasManyCardinality = pathHasManyCardinality; exports.getPathDepth = getPathDepth; exports.getTargetAttributeName = getTargetAttributeName; exports.getRelationPath = getRelationPath; exports.traversePath = traversePath; exports.resolveSingleValue = resolveSingleValue; exports.resolveMultiplePaths = resolveMultiplePaths; exports.NoopHookRegistry = NoopHookRegistry; exports.createMockAdapter = createMockAdapter; exports.PolicyRegistry = PolicyRegistry; exports.defaultPolicyRegistry = defaultPolicyRegistry; exports.BaseService = BaseService; exports.BaseRepository = BaseRepository; exports.SchemaContextAwareRepository = SchemaContextAwareRepository; exports.buildAuditChanges = buildAuditChanges; exports.ObjectSchemaService = ObjectSchemaService; exports.AuditService = AuditService; exports.UserService = UserService; exports.applyDefaultValues = applyDefaultValues; exports.checkPermission = checkPermission; exports.getPolicy = getPolicy; exports.buildPolicyContext = buildPolicyContext; exports.checkRecordAccess = checkRecordAccess; exports.checkRecordModifyOrThrow = checkRecordModifyOrThrow; exports.checkRecordDeleteOrThrow = checkRecordDeleteOrThrow; exports.checkSharedObjectWriteAccess = checkSharedObjectWriteAccess; exports.computeLabel = computeLabel; exports.enrichWithFormulas = enrichWithFormulas; exports.enrichRecordsWithFormulas = enrichRecordsWithFormulas; exports.createContextForCreate = createContextForCreate; exports.createContextForUpdate = createContextForUpdate; exports.createContextForDelete = createContextForDelete; exports.createContextForRestore = createContextForRestore; exports.recalculateParentRollups = recalculateParentRollups; exports.RelationPropertiesService = RelationPropertiesService; exports.RecordQueryService = RecordQueryService; exports.RecordResolverService = RecordResolverService; exports.RelationService = RelationService; exports.RollupService = RollupService; exports.RecordService = RecordService; exports.FormulaResolverService = FormulaResolverService; exports.RollupScheduler = RollupScheduler; exports.DocumentRenderError = DocumentRenderError; exports.StorageDownloadNotSupportedError = StorageDownloadNotSupportedError; exports.DocumentRendererService = DocumentRendererService; exports.DocumentProcessingHook = DocumentProcessingHook; exports.GrantNotFoundError = GrantNotFoundError; exports.GrantExpiredError = GrantExpiredError; exports.GrantRevokedError = GrantRevokedError; exports.TokenRevokedError = TokenRevokedError; exports.WorkflowAccessGrantService = WorkflowAccessGrantService; exports.WorkflowInstanceService = WorkflowInstanceService; exports.InvitationNotFoundError = InvitationNotFoundError; exports.InvitationExpiredError = InvitationExpiredError; exports.InvitationAlreadyAcceptedError = InvitationAlreadyAcceptedError; exports.InvitationRevokedError = InvitationRevokedError; exports.WorkflowInvitationService = WorkflowInvitationService; exports.WorkflowRelationService = WorkflowRelationService; exports.WorkflowService = WorkflowService; exports.UserProfileService = UserProfileService; exports.DocumentGenerationTemplateNotFoundError = DocumentGenerationTemplateNotFoundError; exports.DocumentGenerationNotConfiguredError = DocumentGenerationNotConfiguredError; exports.DocumentGenerationService = DocumentGenerationService; exports.DocumentTemplateService = DocumentTemplateService; exports.DocumentService = DocumentService; exports.DocumentProcessingService = DocumentProcessingService; exports.FileService = FileService; exports.GeocodingService = GeocodingService; exports.GlobalSearchService = GlobalSearchService; exports.PermissionService = PermissionService; exports.ViewService = ViewService; exports.seedRegistryViews = seedRegistryViews; exports.syncNativeViews = syncNativeViews; exports.verifyRegistryViewsSeeded = verifyRegistryViewsSeeded; exports.verifyNativeViewsSync = verifyNativeViewsSync; exports.getViewSeedPreview = getViewSeedPreview; exports.getViewSyncPreview = getViewSyncPreview; exports.syncNativeObjects = syncNativeObjects; exports.verifyNativeObjectsSync = verifyNativeObjectsSync; exports.getSyncPreview = getSyncPreview; exports.syncAll = syncAll;