@stndrds/schema 0.1.0-alpha.57 → 0.1.0-alpha.59

package/dist/{chunk-YVUSATKC.mjs → chunk-O7FGYLYG.mjs}

@@ -1,40 +1,22 @@
+import {
+  asTenantId,
+  asUserId,
+  generateId
+} from "./chunk-V2RPPE2Y.mjs";
+import {
+  computeRecordStatus,
+  formatZodErrors,
+  parseAttributeConfig,
+  validateDraftOrThrow,
+  validateObject,
+  validateObjectOrThrow
+} from "./chunk-SV4BCGQU.mjs";
 import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
 
 // src/runtime/auth/workflow-jwt.service.ts
 import { SignJWT, importPKCS8, importSPKI, jwtVerify } from "jose";
-
-// src/utils.ts
-function asTenantId(id) {
-  return id;
-}
-function asUserId(id) {
-  return id;
-}
-function generateId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-function generatePrefixedId(prefix) {
-  return `${prefix}_${generateId()}`;
-}
-function slugify(input) {
-  return input.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^a-z0-9\s_-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
-}
-function generateTemplateName(label) {
-  const slug = slugify(label) || "template";
-  const suffix = generateId().slice(0, 8);
-  return `${slug}-${suffix}`;
-}
-
-// src/runtime/auth/workflow-jwt.service.ts
 var WorkflowJwtService = class _WorkflowJwtService {
   constructor(config) {
     this.config = config;
@@ -212,6 +194,26 @@ var WorkflowJwtService = class _WorkflowJwtService {
   }
 };
 
+// src/lib/object-helpers.ts
+function isEmpty(obj) {
+  if (obj === null || obj === void 0) {
+    return true;
+  }
+  if (typeof obj !== "object") {
+    return false;
+  }
+  return Object.keys(obj).length === 0;
+}
+function isNotEmpty(obj) {
+  return obj !== null && obj !== void 0 && typeof obj === "object" && Object.keys(obj).length > 0;
+}
+function toUndefinedIfEmpty(obj) {
+  return isNotEmpty(obj) ? obj : void 0;
+}
+function hasProperties(obj) {
+  return isNotEmpty(obj);
+}
+
 // src/runtime/cache.ts
 function fnv1aHash(str) {
   let hash = 2166136261;
@@ -222,7 +224,7 @@ function fnv1aHash(str) {
   return hash.toString(16).padStart(8, "0");
 }
 function hashOptions(options) {
-  if (options === null || options === void 0 || typeof options === "object" && Object.keys(options).length === 0) {
+  if (isEmpty(options)) {
     return "default";
   }
   const sortedJson = JSON.stringify(options, (_, value) => {
@@ -1345,12 +1347,6 @@ function or(...rules) {
 function inValues(field, values) {
   return { field, operator: "in", value: values };
 }
-function isEmpty(field) {
-  return { field, operator: "isEmpty", value: null };
-}
-function isNotEmpty(field) {
-  return { field, operator: "isNotEmpty", value: null };
-}
 
 // src/types/workflows/definition.ts
 function isWorkflowDefinition(obj) {
@@ -1460,16 +1456,6 @@ function setContextValue(context, path, value) {
   }
   current[parts[parts.length - 1]] = value;
 }
-function mergeFormToSlot(context, nodeId, slotId) {
-  const formData = context.forms[nodeId];
-  if (!formData) {
-    return;
-  }
-  if (!context.slots[slotId]) {
-    context.slots[slotId] = {};
-  }
-  Object.assign(context.slots[slotId], formData);
-}
 
 // src/types/workflows/theme.ts
 var DEFAULT_THEME = {
@@ -1823,9 +1809,9 @@ function compareValues(actual, operator, expected) {
       return typeof actual === "string" && typeof expected === "string" ? actual.endsWith(expected) : false;
     // Presence
     case "isEmpty":
-      return isEmpty2(actual);
+      return isEmptyValue(actual);
     case "isNotEmpty":
-      return !isEmpty2(actual);
+      return !isEmptyValue(actual);
     // Set membership
     case "in":
       if (Array.isArray(expected)) {
@@ -1841,7 +1827,7 @@ function compareValues(actual, operator, expected) {
       return false;
   }
 }
-function isEmpty2(value) {
+function isEmptyValue(value) {
   if (value === null || value === void 0) {
     return true;
   }
@@ -1851,7 +1837,7 @@ function isEmpty2(value) {
   if (Array.isArray(value) && value.length === 0) {
     return true;
   }
-  if (typeof value === "object" && Object.keys(value).length === 0) {
+  if (typeof value === "object" && isEmpty(value)) {
     return true;
   }
   return false;
@@ -2096,7 +2082,7 @@ var DocumentExecutor = class {
   validateSlotReferences(node, workflowSlots) {
     const errors = [];
     if (node.targetSlotIds && node.targetSlotIds.length > 0) {
-      const slotIdSet = new Set(workflowSlots.map((s) => s.id));
+      const slotIdSet = workflowSlots.reduce((set, s) => set.add(s.id), /* @__PURE__ */ new Set());
       for (const slotId of node.targetSlotIds) {
         if (!slotIdSet.has(slotId)) {
           errors.push(
@@ -2132,24 +2118,25 @@ var FormExecutor = class {
   }
   execute(node, context) {
     const { input } = context;
-    if (!input || Object.keys(input).length === 0) {
+    if (isEmpty(input)) {
       const requiredParticipationId = node.participantId ?? void 0;
       return wait(`Waiting for form submission: ${node.label}`, {
         requiredParticipationId
       });
     }
+    const formInput = input;
     const slotIds = this.extractSlotIds(node);
     if (slotIds.size === 0) {
       return error("MISSING_FIELDS", "FormNode must have fields or rows with slot references");
     }
     const contextUpdates = {
       forms: {
-        [node.id]: input
+        [node.id]: formInput
       },
       slots: {}
     };
     for (const slotId of slotIds) {
-      const slotInput = input[slotId] ?? {};
+      const slotInput = formInput[slotId] ?? {};
       if (!contextUpdates.slots) {
         contextUpdates.slots = {};
       }
@@ -2177,9 +2164,9 @@ var FormExecutor = class {
   }
   canExecute(node, context) {
     if (node.participantId && context.executorId) {
-      return context.input !== void 0 && Object.keys(context.input).length > 0;
+      return hasProperties(context.input);
     }
-    return context.input !== void 0 && Object.keys(context.input).length > 0;
+    return hasProperties(context.input);
   }
   validate(node) {
     const errors = [];
@@ -3471,9 +3458,6 @@ var ConcurrentModificationError = class extends SchemaError {
     );
   }
 };
-function isConcurrentModificationError(error2) {
-  return error2 instanceof ConcurrentModificationError;
-}
 
 // src/format.ts
 import { getCountryByIso3 } from "@stndrds/constants";
@@ -4075,6 +4059,91 @@ function createMockObjectRecordsRepository(stores) {
   };
 }
 
+// src/runtime/mock/mock-relation-attributes.ts
+import { randomUUID } from "crypto";
+function createMockRelationAttributesRepository(stores) {
+  return {
+    async upsertBatch(items) {
+      const context = getContext2();
+      if (!context) {
+        throw new Error("Context required for relationAttributes operations");
+      }
+      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
+        );
+        if (existing) {
+          existing.properties = item.properties ?? {};
+          existing.updatedAt = /* @__PURE__ */ new Date();
+          existing.updatedBy = item.updatedBy ?? context.userId ?? null;
+          results.push(existing);
+        } else {
+          const row = {
+            id: randomUUID(),
+            tenantId: context.tenantId,
+            fromObject: item.fromObject,
+            fromId: item.fromId,
+            fromAttribute: item.fromAttribute,
+            toId: item.toId,
+            properties: item.properties ?? {},
+            createdAt: /* @__PURE__ */ new Date(),
+            updatedAt: /* @__PURE__ */ new Date(),
+            createdBy: item.createdBy ?? context.userId ?? null,
+            updatedBy: item.updatedBy ?? context.userId ?? null
+          };
+          stores.relationAttributes.set(row.id, row);
+          results.push(row);
+        }
+      }
+      return results;
+    },
+    async findBySource(fromObject, fromId, 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 && row.fromId === fromId && row.fromAttribute === fromAttribute
+      );
+    },
+    async findByTarget(toId) {
+      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.toId === toId
+      );
+    },
+    async deleteBySource(fromObject, fromId, fromAttribute) {
+      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
+      );
+      for (const [id] of toDelete) {
+        stores.relationAttributes.delete(id);
+      }
+    },
+    async deleteByTarget(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.toId === toId
+      );
+      for (const [id] of toDelete) {
+        stores.relationAttributes.delete(id);
+      }
+    }
+  };
+}
+
 // src/runtime/mock/mock-stores.ts
 function createEmptyStores() {
   return {
@@ -4095,7 +4164,8 @@ function createEmptyStores() {
     aiConversations: /* @__PURE__ */ new Map(),
     aiMessages: /* @__PURE__ */ new Map(),
     aiUserMemory: /* @__PURE__ */ new Map(),
-    aiUsageMetrics: /* @__PURE__ */ new Map()
+    aiUsageMetrics: /* @__PURE__ */ new Map(),
+    relationAttributes: /* @__PURE__ */ new Map()
   };
 }
 
@@ -4302,7 +4372,8 @@ function createMockPermissionsRepository(stores) {
     getUserRoles(userProfileId) {
       const tenantId = getTenantId();
       const roleIds = Array.from(stores.userRoles.values()).filter((ur) => ur.userProfileId === userProfileId && ur.tenantId === tenantId).map((ur) => ur.roleId);
-      const roles = Array.from(stores.roles.values()).filter((r) => roleIds.includes(r.id));
+      const roleIdsSet = new Set(roleIds);
+      const roles = Array.from(stores.roles.values()).filter((r) => roleIdsSet.has(r.id));
       return Promise.resolve(roles);
     },
     assignRole(input) {
@@ -4518,7 +4589,7 @@ function createMockViewOverlaysRepository(stores) {
       const views = Array.from(stores.views.values()).filter(
         (v) => v.tenantId === tenantId && v.objectName === objectName && v.type === type
       );
-      const viewIds = new Set(views.map((v) => v.id));
+      const viewIds = views.reduce((set, v) => set.add(v.id), /* @__PURE__ */ new Set());
       return Promise.resolve(
         Array.from(stores.viewOverlays.values()).find(
           (o) => o.tenantId === tenantId && o.userId === userId && o.isUserDefault === true && viewIds.has(o.viewId)
@@ -4603,7 +4674,7 @@ function createMockViewOverlaysRepository(stores) {
       const views = Array.from(stores.views.values()).filter(
         (v) => v.tenantId === tenantId && v.objectName === objectName && v.type === type
       );
-      const viewIds = new Set(views.map((v) => v.id));
+      const viewIds = views.reduce((set, v) => set.add(v.id), /* @__PURE__ */ new Set());
       for (const overlay of stores.viewOverlays.values()) {
         if (overlay.tenantId === tenantId && overlay.userId === userId && overlay.isUserDefault === true && viewIds.has(overlay.viewId)) {
           overlay.isUserDefault = false;
@@ -5009,6 +5080,8 @@ function createMockAdapter() {
     aiConversations: createMockAIConversationsRepository(stores),
     aiUserMemory: createMockAIUserMemoryRepository(stores),
     aiUsageMetrics: createMockAIUsageMetricsRepository(stores),
+    // Relation attributes repository
+    relationAttributes: createMockRelationAttributesRepository(stores),
     async transaction(callback) {
       return await callback(adapter);
     },
@@ -5034,6 +5107,7 @@ function createMockAdapter() {
       stores.aiMessages.clear();
       stores.aiUserMemory.clear();
       stores.aiUsageMetrics.clear();
+      stores.relationAttributes.clear();
     }
   };
   return adapter;
@@ -5512,6 +5586,292 @@ 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) {
@@ -6068,6 +6428,32 @@ var SingleRelationAttributeBuilder = class extends BaseAttributeBuilder {
     );
     return multiBuilder;
   }
+  /**
+   * Add properties to qualify the relation
+   * 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))
+   *   )
+   * ```
+   */
+  qualifyWith(configure) {
+    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(...)'
+      );
+    }
+    const builder = new PropertySchemaBuilder();
+    const schema = configure(builder).build();
+    this.attr.properties = schema;
+    return this;
+  }
   required() {
     this.setRequired(true);
     return this;
@@ -6129,6 +6515,33 @@ 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;
@@ -6514,7 +6927,7 @@ function object(config) {
 }
 
 // src/builders/view-builder.ts
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 import { z as z3 } from "zod";
 var GroupBuilder = class {
   constructor(id, label) {
@@ -7374,7 +7787,7 @@ var ListViewBuilder = class {
       columns: this.data.columns,
       columnSizing: this.data.columnSizing,
       defaultFilters: this.data.defaultFilters ? {
-        id: randomUUID(),
+        id: randomUUID2(),
         combinator: this.data.defaultFilters.combinator,
         rules: this.data.defaultFilters.rules
       } : void 0,
@@ -7385,7 +7798,7 @@ var ListViewBuilder = class {
         label: tab.label,
         icon: tab.icon,
         filters: tab.filters ? {
-          id: randomUUID(),
+          id: randomUUID2(),
           combinator: tab.filters.combinator,
           rules: tab.filters.rules
         } : void 0,
@@ -7899,13 +8312,13 @@ var WorkflowBuilder = class {
     if (!this.startNodeId) {
       throw new Error("[WorkflowBuilder] A start node is required. Use .start() to add one.");
     }
-    if (!this.data.nodes || Object.keys(this.data.nodes).length === 0) {
+    if (isEmpty(this.data.nodes)) {
       throw new Error("[WorkflowBuilder] At least one node is required.");
     }
     if (!this.data.slots || this.data.slots.length === 0) {
       throw new Error("[WorkflowBuilder] At least one slot is required. Use .slot() to add slots.");
     }
-    const hasEndNode = Object.values(this.data.nodes).some((n) => n.type === "end");
+    const hasEndNode = this.data.nodes ? Object.values(this.data.nodes).some((n) => n.type === "end") : false;
     if (!hasEndNode) {
       throw new Error(
         "[WorkflowBuilder] At least one end node is required. Use .end() to add one."
@@ -7936,7 +8349,7 @@ var WorkflowBuilder = class {
     }
   }
   validateSlotReferences() {
-    const slotIds = new Set(this.data.slots?.map((s) => s.id) ?? []);
+    const slotIds = this.data.slots?.reduce((set, s) => set.add(s.id), /* @__PURE__ */ new Set()) ?? /* @__PURE__ */ new Set();
     for (const node of Object.values(this.data.nodes ?? {})) {
       if (node.type === "form") {
         const referencedSlots = /* @__PURE__ */ new Set();
@@ -8041,22 +8454,6 @@ function isBehaviorProperty(property) {
 function isPresentationProperty(property) {
   return PRESENTATION_PROPERTIES.includes(property);
 }
-function getPropertyProtectionLevel(property) {
-  if (isIdentityProperty(property)) return "identity";
-  if (isBehaviorProperty(property)) return "behavior";
-  if (isPresentationProperty(property)) return "presentation";
-  return "unknown";
-}
-function filterPropertiesByCategory(properties, category) {
-  switch (category) {
-    case "identity":
-      return properties.filter(isIdentityProperty);
-    case "behavior":
-      return properties.filter(isBehaviorProperty);
-    case "presentation":
-      return properties.filter(isPresentationProperty);
-  }
-}
 
 // src/types/errors.ts
 var RecordReferencedError = class extends Error {
@@ -8075,656 +8472,99 @@ var AttributeInUseError = class extends Error {
     this.attributeName = attributeName;
     this.usage = usage;
     this.code = "ATTRIBUTE_IN_USE";
-    this.name = "AttributeInUseError";
-  }
-};
-var ObjectReferencedError = class extends Error {
-  constructor(objectName, referencingObjects) {
-    super(
-      `Cannot delete object "${objectName}": target of relations in ${referencingObjects.join(", ")}`
-    );
-    this.objectName = objectName;
-    this.referencingObjects = referencingObjects;
-    this.code = "OBJECT_REFERENCED";
-    this.name = "ObjectReferencedError";
-  }
-};
-
-// src/types/system-attributes.ts
-var SYSTEM_ATTRIBUTES = {
-  createdAt: {
-    id: "system:createdAt",
-    name: "createdAt",
-    label: "Created time",
-    type: "date",
-    required: false,
-    disabled: true,
-    system: true,
-    icon: "clock-circle",
-    description: "When this record was created"
-  },
-  updatedAt: {
-    id: "system:updatedAt",
-    name: "updatedAt",
-    label: "Last edited time",
-    type: "date",
-    required: false,
-    disabled: true,
-    system: true,
-    icon: "clock-circle",
-    description: "When this record was last modified"
-  },
-  createdBy: {
-    id: "system:createdBy",
-    name: "createdBy",
-    label: "Created by",
-    type: "user",
-    required: false,
-    disabled: true,
-    system: true,
-    multiple: false,
-    icon: "user",
-    description: "User who created this record"
-  },
-  lastUpdatedBy: {
-    id: "system:lastUpdatedBy",
-    name: "lastUpdatedBy",
-    label: "Last edited by",
-    type: "user",
-    required: false,
-    disabled: true,
-    system: true,
-    multiple: false,
-    icon: "user",
-    description: "User who last modified this record"
-  },
-  /**
-   * System attribute for free-form document attachments.
-   * Hidden from forms, visible in Documents tab.
-   * Users can attach any document without template constraints.
-   */
-  attachments: {
-    id: "system:attachments",
-    name: "attachments",
-    label: "Pi\xE8ces jointes",
-    type: "document",
-    required: false,
-    disabled: false,
-    // Editable via Documents tab
-    system: true,
-    hidden: true,
-    // Hidden from regular form views
-    multiple: true,
-    icon: "paperclip",
-    description: "Free-form document attachments"
-    // No templateId = all templates allowed
-  }
-};
-function getSystemAttributeList() {
-  return Object.values(SYSTEM_ATTRIBUTES);
-}
-function isSystemAttribute(name) {
-  return name in SYSTEM_ATTRIBUTES;
-}
-function isSystemAttributeObject(attr) {
-  return attr.system === true;
-}
-
-// src/validation/validators.ts
-import { z as z5 } from "zod";
-var regexPatternCache = /* @__PURE__ */ new Map();
-function getCachedRegex(pattern) {
-  let cached = regexPatternCache.get(pattern);
-  if (!cached) {
-    cached = new RegExp(pattern);
-    regexPatternCache.set(pattern, cached);
-  }
-  return cached;
-}
-var DEFAULT_VALIDATION_MESSAGES = {
-  required: (attr) => `${attr.label} is required`,
-  invalidType: (attr, expected) => `${attr.label} must be a ${expected}`,
-  minLength: (attr, min) => `${attr.label} must be at least ${min} characters`,
-  maxLength: (attr, max) => `${attr.label} must be at most ${max} characters`,
-  invalidPattern: (attr) => `${attr.label} format is invalid`,
-  minValue: (attr, min) => `${attr.label} must be at least ${min}`,
-  maxValue: (attr, max) => `${attr.label} must be at most ${max}`,
-  mustBeInteger: (attr) => `${attr.label} must be an integer`,
-  invalidDate: (attr) => `${attr.label} must be a valid date`,
-  invalidOption: (attr, options) => `${attr.label} must be one of: ${options.join(", ")}`,
-  invalidId: (attr) => `${attr.label} must be a valid ID`,
-  minItems: (attr, min) => `${attr.label} must have at least ${min} item${min > 1 ? "s" : ""}`,
-  maxItems: (attr, max) => `${attr.label} must have at most ${max} item${max > 1 ? "s" : ""}`,
-  invalidRichtext: (attr) => `${attr.label} must be valid rich text content`,
-  invalidPhone: (attr) => `${attr.label} must be a valid phone number`,
-  invalidCurrency: (attr) => `${attr.label} must be a valid currency value`,
-  invalidLocation: (attr) => `${attr.label} must be a valid location`
-};
-var baseConfigSchema = z5.object({
-  disabled: z5.boolean().optional(),
-  placeholder: z5.string().optional(),
-  description: z5.string().optional(),
-  defaultValue: z5.unknown().optional(),
-  icon: z5.string().optional(),
-  order: z5.number().int().optional(),
-  hidden: z5.boolean().optional(),
-  archived: z5.boolean().optional(),
-  deprecated: z5.boolean().optional(),
-  metadata: z5.record(z5.string(), z5.unknown()).optional()
-});
-var optionSchema = z5.object({
-  id: z5.string().min(1),
-  label: z5.string().min(1),
-  value: z5.string().min(1),
-  color: z5.string().optional(),
-  icon: z5.string().optional(),
-  description: z5.string().optional(),
-  group: z5.enum(["idle", "in_progress", "finished"]).optional()
-});
-var optionsArraySchema = z5.array(optionSchema).min(1).refine(
-  (options) => {
-    const values = options.map((o) => o.value);
-    return new Set(values).size === values.length;
-  },
-  { message: "Duplicate option values are not allowed" }
-);
-var relationTargetSchema = z5.object({
-  object: z5.string().min(1),
-  displayTemplate: z5.string().optional(),
-  filter: z5.record(z5.string(), z5.unknown()).optional()
-});
-var textConfigSchema = baseConfigSchema.extend({
-  minLength: z5.number().int().min(0).optional(),
-  maxLength: z5.number().int().min(1).optional(),
-  pattern: z5.string().optional()
-});
-var textareaConfigSchema = baseConfigSchema;
-var richtextConfigSchema = baseConfigSchema.extend({
-  features: z5.array(
-    z5.enum(["headings", "bold", "italic", "lists", "links", "images", "codeBlocks", "tables"])
-  ).optional()
-});
-var numberConfigSchema = baseConfigSchema.extend({
-  min: z5.number().optional(),
-  max: z5.number().optional(),
-  unit: z5.enum(["integer", "decimal", "percentage"]).optional(),
-  decimals: z5.number().int().min(0).optional()
-});
-var checkboxConfigSchema = baseConfigSchema;
-var dateConfigSchema = baseConfigSchema.extend({
-  dateFormat: z5.enum(["short", "long", "full", "relative"]).optional(),
-  minDate: z5.string().optional(),
-  maxDate: z5.string().optional()
-});
-var phoneConfigSchema = baseConfigSchema.extend({
-  defaultCountryCode: z5.string().length(3).optional()
-});
-var currencyConfigSchema = baseConfigSchema.extend({
-  defaultCurrency: z5.string().length(3).optional(),
-  allowedCurrencies: z5.array(z5.string().length(3)).optional()
-});
-var statusConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var locationConfigSchema = baseConfigSchema.extend({
-  granularity: z5.enum(["full", "address", "city", "state", "country", "coordinates"]),
-  enableAutocomplete: z5.boolean().optional(),
-  enableMap: z5.boolean().optional(),
-  defaultCountry: z5.string().length(3).optional(),
-  allowedCountries: z5.array(z5.string().length(3)).optional(),
-  displayFormat: z5.enum(["single_line", "multi_line", "compact"]).optional()
-});
-var selectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var multiselectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var fileConfigSchema = baseConfigSchema.extend({
-  maxFiles: z5.number().int().min(1).optional(),
-  maxSize: z5.number().int().min(1).optional(),
-  allowedTypes: z5.array(z5.string()).optional(),
-  multiple: z5.boolean().optional()
-});
-var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: z5.array(z5.string()).optional(),
-  multiple: z5.boolean().optional()
-});
-var relationConfigSchema = baseConfigSchema.extend({
-  targets: z5.array(relationTargetSchema).min(1),
-  cardinality: z5.enum(["one", "many"]),
-  minItems: z5.number().int().min(0).optional(),
-  maxItems: z5.number().int().min(1).optional()
-});
-var ratingConfigSchema = baseConfigSchema.extend({
-  max: z5.number().int().min(1).optional(),
-  iconType: z5.enum(["star", "heart", "thumbs", "number"]).optional()
-});
-var formulaConfigSchema = baseConfigSchema.extend({
-  expression: z5.string().min(1),
-  returnType: z5.enum(["text", "number", "boolean", "date"]),
-  decimals: z5.number().int().min(0).max(10).optional(),
-  allowRelations: z5.boolean().optional()
-});
-var rollupConfigSchema = baseConfigSchema.extend({
-  relationAttribute: z5.string().min(1).optional(),
-  relationPath: z5.string().optional(),
-  targetAttribute: z5.string().min(1),
-  function: z5.enum([
-    // Numeric aggregates
-    "sum",
-    "avg",
-    // Date aggregates
-    "earliest",
-    "latest",
-    // Count (universal)
-    "count",
-    "countValues",
-    "countUniqueValues",
-    "countEmpty",
-    // Percent (universal)
-    "percentEmpty",
-    "percentNotEmpty",
-    // Lookup (universal)
-    "original"
-  ]),
-  decimals: z5.number().int().min(0).max(10).optional(),
-  targetAttributeType: z5.string().optional(),
-  targetAttributeOptions: z5.array(
-    z5.object({
-      id: z5.string(),
-      label: z5.string(),
-      value: z5.string(),
-      color: z5.string().optional(),
-      icon: z5.string().optional(),
-      description: z5.string().optional(),
-      group: z5.enum(["idle", "in_progress", "finished"]).optional()
-    })
-  ).optional()
-});
-var documentConfigSchema = baseConfigSchema.extend({
-  templateId: z5.string().optional(),
-  allowedTemplates: z5.array(z5.string()).optional(),
-  multiple: z5.boolean().optional(),
-  maxDocuments: z5.number().int().min(1).optional(),
-  autoProcess: z5.boolean().optional()
-});
-var attributeConfigSchemas = {
-  text: textConfigSchema,
-  textarea: textareaConfigSchema,
-  richtext: richtextConfigSchema,
-  number: numberConfigSchema,
-  checkbox: checkboxConfigSchema,
-  date: dateConfigSchema,
-  phone: phoneConfigSchema,
-  currency: currencyConfigSchema,
-  status: statusConfigSchema,
-  location: locationConfigSchema,
-  select: selectConfigSchema,
-  multiselect: multiselectConfigSchema,
-  file: fileConfigSchema,
-  user: userConfigSchema,
-  relation: relationConfigSchema,
-  rating: ratingConfigSchema,
-  formula: formulaConfigSchema,
-  rollup: rollupConfigSchema,
-  document: documentConfigSchema
-};
-function getAttributeConfigSchema(type) {
-  return attributeConfigSchemas[type];
-}
-function validateAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  const result = schema.safeParse(config);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`)
-  };
-}
-function parseAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  return schema.strip().parse(config);
-}
-function safeParseAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  const result = schema.strip().safeParse(config);
-  return result.success ? result.data : void 0;
-}
-function createTextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  let schema = z5.string();
-  if (attr.minLength !== void 0) {
-    schema = schema.min(attr.minLength, messages.minLength(attr, attr.minLength));
-  }
-  if (attr.maxLength !== void 0) {
-    schema = schema.max(attr.maxLength, messages.maxLength(attr, attr.maxLength));
-  }
-  if (attr.pattern) {
-    schema = schema.regex(getCachedRegex(attr.pattern), messages.invalidPattern(attr));
-  }
-  return schema;
-}
-function createNumberValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  let schema = z5.number();
-  if (attr.min !== void 0) {
-    schema = schema.min(attr.min, messages.minValue(attr, attr.min));
-  }
-  if (attr.max !== void 0) {
-    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
-  }
-  if (attr.unit === "integer") {
-    schema = schema.int(messages.mustBeInteger(attr));
-  }
-  return schema;
-}
-function createCheckboxValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.boolean();
-}
-function createDateValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.coerce.date({ message: messages.invalidDate(attr) });
-}
-function createPhoneValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.object(
-    {
-      countryCode: z5.string().length(3),
-      phoneNumber: z5.string().min(1)
-    },
-    { message: messages.invalidPhone(attr) }
-  );
-}
-function createCurrencyValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.object(
-    {
-      code: z5.string().length(3),
-      value: z5.number().min(0)
-    },
-    { message: messages.invalidCurrency(attr) }
-  );
-}
-function createStatusValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  return z5.enum(validValues, {
-    message: messages.invalidOption(attr, validValues)
-  });
-}
-function createSelectValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  return z5.enum(validValues, {
-    message: messages.invalidOption(attr, validValues)
-  });
-}
-function createMultiselectValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  return z5.array(
-    z5.enum(validValues, {
-      message: messages.invalidOption(attr, validValues)
-    })
-  );
-}
-function createLocationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.object(
-    {
-      address: z5.string().optional(),
-      address2: z5.string().optional(),
-      city: z5.string().optional(),
-      state: z5.string().optional(),
-      postalCode: z5.string().optional(),
-      country: z5.string().length(3).optional(),
-      latitude: z5.number().optional(),
-      longitude: z5.number().optional()
-    },
-    { message: messages.invalidLocation(attr) }
-  );
-}
-function createFileValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  if (attr.multiple) {
-    let arraySchema = z5.array(uuidSchema);
-    if (attr.maxFiles) {
-      arraySchema = arraySchema.max(attr.maxFiles, messages.maxItems(attr, attr.maxFiles));
-    }
-    return arraySchema;
-  }
-  return uuidSchema;
-}
-function createUserValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  if (attr.multiple) {
-    return z5.array(uuidSchema);
-  }
-  return uuidSchema;
-}
-function createSingleRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  return z5.union([uuidSchema, z5.null()]);
-}
-function createMultiRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  let arraySchema = z5.array(uuidSchema);
-  if (attr.minItems !== void 0) {
-    arraySchema = arraySchema.min(attr.minItems, messages.minItems(attr, attr.minItems));
-  }
-  if (attr.maxItems !== void 0) {
-    arraySchema = arraySchema.max(attr.maxItems, messages.maxItems(attr, attr.maxItems));
-  }
-  return arraySchema;
-}
-function createRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  if (attr.cardinality === "many") {
-    return createMultiRelationValidator(attr, messages);
-  }
-  return createSingleRelationValidator(attr, messages);
-}
-function createRatingValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  let schema = z5.number().min(0);
-  if (attr.max !== void 0) {
-    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
-  }
-  return schema;
-}
-function createFormulaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.unknown();
-}
-function createRollupValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.unknown();
-}
-function createTextAreaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.string();
-}
-function createRichtextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.string({
-    message: messages.invalidRichtext(attr)
-  });
-}
-function createAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  switch (attr.type) {
-    case "text":
-      return createTextValidator(attr, messages);
-    case "textarea":
-      return createTextAreaValidator(attr, messages);
-    case "richtext":
-      return createRichtextValidator(attr, messages);
-    case "number":
-      return createNumberValidator(attr, messages);
-    case "checkbox":
-      return createCheckboxValidator(attr, messages);
-    case "date":
-      return createDateValidator(attr, messages);
-    case "phone":
-      return createPhoneValidator(attr, messages);
-    case "currency":
-      return createCurrencyValidator(attr, messages);
-    case "status":
-      return createStatusValidator(attr, messages);
-    case "location":
-      return createLocationValidator(attr, messages);
-    case "select":
-      return createSelectValidator(attr, messages);
-    case "multiselect":
-      return createMultiselectValidator(attr, messages);
-    case "file":
-      return createFileValidator(attr, messages);
-    case "user":
-      return createUserValidator(attr, messages);
-    case "relation":
-      return createRelationValidator(attr, messages);
-    case "rating":
-      return createRatingValidator(attr, messages);
-    case "formula":
-      return createFormulaValidator(attr, messages);
-    case "rollup":
-      return createRollupValidator(attr, messages);
-    default:
-      return z5.unknown();
-  }
-}
-function isEmptyValue(value) {
-  if (value === null || value === void 0) return true;
-  if (typeof value === "string" && value.trim() === "") return true;
-  if (value instanceof Date) return false;
-  if (typeof value === "object" && !Array.isArray(value)) {
-    return Object.values(value).every(
-      (v) => v === null || v === void 0 || typeof v === "string" && v.trim() === ""
-    );
-  }
-  return false;
-}
-function withEmptyToNull(validator) {
-  return z5.preprocess((val) => isEmptyValue(val) ? null : val, validator.nullish());
-}
-function createFormAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validator = createAttributeValidator(attr, messages);
-  if (!attr.required) {
-    return withEmptyToNull(validator);
-  }
-  return validator;
-}
-function createObjectValidator(objectDef) {
-  const shape = {};
-  for (const attr of objectDef.attributes) {
-    const validator = createAttributeValidator(attr);
-    shape[attr.name] = attr.required ? validator : withEmptyToNull(validator);
-  }
-  return z5.object(shape).passthrough();
-}
-function validateAttribute(attr, value) {
-  const validator = createAttributeValidator(attr);
-  if (!attr.required && (value === void 0 || value === null)) {
-    return { success: true, data: { [attr.name]: value } };
-  }
-  const result = validator.safeParse(value);
-  if (result.success) {
-    return {
-      success: true,
-      data: { [attr.name]: result.data }
-    };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.map((err) => ({
-      path: [attr.name, ...err.path.map(String)],
-      message: err.message
-    }))
-  };
-}
-function validateObject(objectDef, data) {
-  const validator = createObjectValidator(objectDef);
-  const result = validator.safeParse(data);
-  if (result.success) {
-    return {
-      success: true,
-      data: result.data
-    };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.map((err) => ({
-      path: err.path.map(String),
-      message: err.message
-    }))
-  };
-}
-function validateObjectOrThrow(objectDef, data) {
-  const result = validateObject(objectDef, data);
-  if (!result.success) {
-    const errorMessages = result.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
-    throw new Error(`Validation failed for ${objectDef.label}:
-${errorMessages}`);
-  }
-  return result.data;
-}
-function createDraftValidator(objectDef) {
-  const shape = {};
-  for (const attr of objectDef.attributes) {
-    const validator = createAttributeValidator(attr);
-    shape[attr.name] = withEmptyToNull(validator);
-  }
-  return z5.object(shape).passthrough();
-}
-function validateDraft(objectDef, data) {
-  const validator = createDraftValidator(objectDef);
-  const result = validator.safeParse(data);
-  if (result.success) {
-    return {
-      success: true,
-      data: result.data
-    };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.map((err) => ({
-      path: err.path.map(String),
-      message: err.message
-    }))
-  };
-}
-function validateDraftOrThrow(objectDef, data) {
-  const result = validateDraft(objectDef, data);
-  if (!result.success) {
-    const errorMessages = result.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
-    throw new Error(`Draft validation failed for ${objectDef.label}:
-${errorMessages}`);
-  }
-  return result.data;
-}
-function isValuePresent(value) {
-  if (value === void 0 || value === null) {
-    return false;
+    this.name = "AttributeInUseError";
   }
-  if (typeof value === "string" && value.trim() === "") {
-    return false;
+};
+var ObjectReferencedError = class extends Error {
+  constructor(objectName, referencingObjects) {
+    super(
+      `Cannot delete object "${objectName}": target of relations in ${referencingObjects.join(", ")}`
+    );
+    this.objectName = objectName;
+    this.referencingObjects = referencingObjects;
+    this.code = "OBJECT_REFERENCED";
+    this.name = "ObjectReferencedError";
   }
-  return true;
-}
-function getMissingRequiredAttributes(objectDef, data) {
-  const missing = [];
-  for (const attr of objectDef.attributes) {
-    if (attr.required && !isValuePresent(data[attr.name])) {
-      missing.push(attr);
-    }
+};
+
+// src/types/system-attributes.ts
+var SYSTEM_ATTRIBUTES = {
+  createdAt: {
+    id: "system:createdAt",
+    name: "createdAt",
+    label: "Created time",
+    type: "date",
+    required: false,
+    disabled: true,
+    system: true,
+    icon: "clock-circle",
+    description: "When this record was created"
+  },
+  updatedAt: {
+    id: "system:updatedAt",
+    name: "updatedAt",
+    label: "Last edited time",
+    type: "date",
+    required: false,
+    disabled: true,
+    system: true,
+    icon: "clock-circle",
+    description: "When this record was last modified"
+  },
+  createdBy: {
+    id: "system:createdBy",
+    name: "createdBy",
+    label: "Created by",
+    type: "user",
+    required: false,
+    disabled: true,
+    system: true,
+    multiple: false,
+    icon: "user",
+    description: "User who created this record"
+  },
+  lastUpdatedBy: {
+    id: "system:lastUpdatedBy",
+    name: "lastUpdatedBy",
+    label: "Last edited by",
+    type: "user",
+    required: false,
+    disabled: true,
+    system: true,
+    multiple: false,
+    icon: "user",
+    description: "User who last modified this record"
+  },
+  /**
+   * System attribute for free-form document attachments.
+   * Hidden from forms, visible in Documents tab.
+   * Users can attach any document without template constraints.
+   */
+  attachments: {
+    id: "system:attachments",
+    name: "attachments",
+    label: "Pi\xE8ces jointes",
+    type: "document",
+    required: false,
+    disabled: false,
+    // Editable via Documents tab
+    system: true,
+    hidden: true,
+    // Hidden from regular form views
+    multiple: true,
+    icon: "paperclip",
+    description: "Free-form document attachments"
+    // No templateId = all templates allowed
   }
-  return missing;
+};
+function getSystemAttributeList() {
+  return Object.values(SYSTEM_ATTRIBUTES);
 }
-function isRecordComplete(objectDef, data) {
-  const missing = getMissingRequiredAttributes(objectDef, data);
-  if (missing.length > 0) {
-    return false;
-  }
-  const validation = validateObject(objectDef, data);
-  return validation.success;
+function isSystemAttribute(name) {
+  return name in SYSTEM_ATTRIBUTES;
 }
-function computeRecordStatus(objectDef, data) {
-  return isRecordComplete(objectDef, data) ? "complete" : "draft";
+function isSystemAttributeObject(attr) {
+  return attr.system === true;
 }
 
 // src/runtime/services/audit/helpers.ts
@@ -10238,7 +10078,7 @@ async function preloadSchemas(records, schemaService) {
   if (records.length === 0) {
     return schemasByObjectId;
   }
-  const uniqueObjectIds = [...new Set(records.map((r) => r.objectId))];
+  const uniqueObjectIds = [...records.reduce((set, r) => set.add(r.objectId), /* @__PURE__ */ new Set())];
   await Promise.all(
     uniqueObjectIds.map(async (objId) => {
       const schema = await schemaService.getObjectSchema(objId);
@@ -10387,6 +10227,13 @@ var RecordQueryService = class extends BaseService {
       effectiveTotal = exhausted ? collected.length : Math.max(collected.length, result.total);
       filteredRecords = collected.slice(requestedOffset, requestedOffset + requestedLimit);
     }
+    if (options?.include && options.include.length > 0) {
+      filteredRecords = await this.includeRelationsWithProperties(
+        filteredRecords,
+        schema,
+        options.include
+      );
+    }
     if (!options?.skipFormulas) {
       return {
         records: enrichRecordsWithFormulas(filteredRecords, schema),
@@ -10462,6 +10309,79 @@ var RecordQueryService = class extends BaseService {
     }
     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
@@ -10556,6 +10476,280 @@ var RecordResolverService = class extends BaseService {
   }
 };
 
+// src/runtime/services/record/relation-properties.service.ts
+import { z as z5 } from "zod";
+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;
+  }
+  /**
+   * 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;
+    }
+    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 adapter.relationAttributes?.findBySource(
+      schema.name,
+      recordId,
+      attributeName
+    );
+    const existingIds = new Set((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: item.props ?? {},
+        updatedBy: this.userId ?? void 0,
+        createdBy: 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: item.props ?? {},
+          updatedBy: this.userId ?? void 0,
+          createdBy: this.userId ?? void 0
+        }));
+        await adapter.relationAttributes.upsertBatch(inputs);
+      }
+    }
+  }
+  /**
+   * Validate relation properties against PropertySchema.
+   *
+   * Uses Zod for runtime validation based on PropertyDefinition 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
+  // ============================================================================
+  /**
+   * 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)
+   *
+   * @param value - Relation value in hybrid format
+   * @returns Normalized array of relation items
+   * @private
+   */
+  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 [];
+  }
+  /**
+   * Build Zod schema from PropertySchema definition.
+   *
+   * Dynamically generates validation schema based on PropertyDefinition types.
+   *
+   * @param propertySchema - PropertySchema with definitions
+   * @returns Zod schema for validation
+   * @private
+   */
+  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 z5.object(shape);
+  }
+  /**
+   * Build Zod schema for a single property field.
+   *
+   * @param def - PropertyDefinition
+   * @returns Zod schema for the field
+   * @private
+   */
+  buildFieldSchema(def) {
+    switch (def.type) {
+      case "text":
+      case "textarea": {
+        let schema = z5.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 = z5.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 z5.boolean();
+      }
+      case "date": {
+        const schema = z5.string().datetime();
+        return schema;
+      }
+      case "phone": {
+        return z5.string();
+      }
+      case "currency": {
+        let schema = z5.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 z5.enum(validValues);
+      }
+      case "multiselect": {
+        const validValues = def.options.map((opt) => opt.value);
+        let schema = z5.array(z5.enum(validValues));
+        if (def.maxSelections !== void 0) {
+          schema = schema.max(def.maxSelections);
+        }
+        return schema;
+      }
+      case "rating": {
+        let schema = z5.number().int();
+        if (def.max !== void 0) {
+          schema = schema.max(def.max);
+        }
+        return schema.min(0);
+      }
+      case "location": {
+        return z5.object({
+          address: z5.string().optional(),
+          lat: z5.number().optional(),
+          lng: z5.number().optional()
+        });
+      }
+      default: {
+        return z5.unknown();
+      }
+    }
+  }
+};
+
 // src/runtime/services/record/relation.service.ts
 var RelationService = class extends BaseService {
   constructor(adapter, nativeRegistry, options) {
@@ -10885,8 +11079,10 @@ var RelationService = class extends BaseService {
       const [attributeId, recordId] = c.split(":");
       return { compositeId: c, attributeId, recordId };
     });
-    const uniqueRecordIds = [...new Set(parsed.map((p) => p.recordId))];
-    const uniqueAttributeIds = [...new Set(parsed.map((p) => p.attributeId))];
+    const uniqueRecordIds = [...parsed.reduce((set, p) => set.add(p.recordId), /* @__PURE__ */ new Set())];
+    const uniqueAttributeIds = [
+      ...parsed.reduce((set, p) => set.add(p.attributeId), /* @__PURE__ */ new Set())
+    ];
     const records = await this.recordResolver.findByIds(uniqueRecordIds);
     if (records.length === 0) {
       return [];
@@ -10895,7 +11091,7 @@ var RelationService = class extends BaseService {
     const attributePromises = uniqueAttributeIds.map((id) => this.findAttributeById(id));
     const attributes = await Promise.all(attributePromises);
     const attributeMap = new Map(uniqueAttributeIds.map((id, i) => [id, attributes[i]]));
-    const uniqueObjectIds = [...new Set(records.map((r) => r.objectId))];
+    const uniqueObjectIds = [...records.reduce((set, r) => set.add(r.objectId), /* @__PURE__ */ new Set())];
     const schemaPromises = uniqueObjectIds.map((id) => this.schemaService.getObjectSchema(id));
     const schemas = await Promise.all(schemaPromises);
     const schemaMap = new Map(uniqueObjectIds.map((id, i) => [id, schemas[i]]));
@@ -11148,7 +11344,10 @@ var RollupService = class extends BaseService {
         return values.filter((v) => v != null && v !== "").length;
       case "countUniqueValues": {
         const nonEmpty = values.filter((v) => v != null && v !== "");
-        return new Set(nonEmpty.map((v) => JSON.stringify(v))).size;
+        return nonEmpty.reduce(
+          (set, v) => set.add(JSON.stringify(v)),
+          /* @__PURE__ */ new Set()
+        ).size;
       }
       case "countEmpty":
         return values.filter((v) => v == null || v === "").length;
@@ -11379,6 +11578,7 @@ var RecordService = class extends BaseService {
       queryService: this.queryService,
       recordResolver: this.recordResolver
     });
+    this.relationPropertiesService = new RelationPropertiesService(adapter);
     this.rollupService = new RollupService(adapter, {
       recordResolver: this.recordResolver
     });
@@ -11423,29 +11623,45 @@ var RecordService = class extends BaseService {
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("beforeCreate", schema.name, hookCtx);
     }
+    const normalizedData = this.relationPropertiesService.normalizeRelationValuesForStorage(
+      schema,
+      dataWithDefaults
+    );
     if (options?.validate !== false) {
       if (options?.allowDraft) {
-        validateDraftOrThrow(schema, dataWithDefaults);
+        validateDraftOrThrow(schema, normalizedData);
       } else {
-        validateObjectOrThrow(schema, dataWithDefaults);
+        validateObjectOrThrow(schema, normalizedData);
       }
       if (!options?.skipRelationValidation) {
-        await this.relationService.validateRelationsOrThrow(schema, dataWithDefaults);
+        await this.relationService.validateRelationsOrThrow(schema, normalizedData);
       }
       if (!options?.skipUserValidation) {
-        await this.userService.validateUsersOrThrow(schema, dataWithDefaults);
+        await this.userService.validateUsersOrThrow(schema, normalizedData);
       }
     }
-    const completionStatus = computeRecordStatus(schema, dataWithDefaults);
-    const label = await computeLabel(schema, dataWithDefaults, this.labelResolver);
+    const completionStatus = computeRecordStatus(schema, normalizedData);
+    const label = await computeLabel(schema, normalizedData, this.labelResolver);
     const record = await this.adapter.objectRecords.create({
       objectId,
-      data: dataWithDefaults,
+      data: normalizedData,
       label,
       completionStatus,
       metadata: options?.metadata,
       createdBy: this.userId
     });
+    for (const [attrName, value] of Object.entries(dataWithDefaults)) {
+      const attr = schema.attributes.find((a) => a.name === attrName);
+      if (attr?.type === "relation" && attr.properties) {
+        await this.relationPropertiesService.syncRelationProperties(
+          schema,
+          record.id,
+          attrName,
+          value,
+          this.adapter
+        );
+      }
+    }
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -11576,30 +11792,29 @@ var RecordService = class extends BaseService {
         hookModifiedValues[key] = hookCtx.newValues[key];
       }
     }
+    const dataToUpdate = { ...data, ...hookModifiedValues };
+    const normalizedUpdate = this.relationPropertiesService.normalizeRelationValuesForStorage(
+      schema,
+      dataToUpdate
+    );
+    const normalizedMergedData = { ...existing.values, ...normalizedUpdate };
     if (options?.validate !== false) {
       if (options?.partial) {
-        validateDraftOrThrow(schema, mergedData);
+        validateDraftOrThrow(schema, normalizedMergedData);
       } else {
-        validateObjectOrThrow(schema, mergedData);
+        validateObjectOrThrow(schema, normalizedMergedData);
       }
       if (!options?.skipRelationValidation) {
-        await this.relationService.validateRelationsOrThrow(schema, {
-          ...data,
-          ...hookModifiedValues
-        });
+        await this.relationService.validateRelationsOrThrow(schema, normalizedUpdate);
       }
       if (!options?.skipUserValidation) {
-        await this.userService.validateUsersOrThrow(schema, {
-          ...data,
-          ...hookModifiedValues
-        });
+        await this.userService.validateUsersOrThrow(schema, normalizedUpdate);
       }
     }
-    const completionStatus = computeRecordStatus(schema, mergedData);
-    const label = await computeLabel(schema, mergedData, this.labelResolver);
+    const completionStatus = computeRecordStatus(schema, normalizedMergedData);
+    const label = await computeLabel(schema, normalizedMergedData, this.labelResolver);
     const updatePayload = {
-      ...data,
-      ...hookModifiedValues,
+      ...normalizedUpdate,
       __completionStatus: completionStatus,
       __label: label,
       __lastUpdatedBy: this.userId,
@@ -11615,6 +11830,18 @@ var RecordService = class extends BaseService {
     }
     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 (attr?.type === "relation" && attr.properties) {
+        await this.relationPropertiesService.syncRelationProperties(
+          schema,
+          recordId,
+          attrName,
+          value,
+          this.adapter
+        );
+      }
+    }
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -13987,7 +14214,7 @@ var WorkflowService = class extends BaseService {
     };
     const validationResult = WorkflowDefinitionSchema.safeParse(definition);
     if (!validationResult.success) {
-      const errors = validationResult.error.issues.map((i) => i.message);
+      const errors = formatZodErrors(validationResult.error).map((err) => err.message);
       throw new SchemaError(
         `Invalid workflow definition: ${errors.join(", ")}`,
         SchemaErrorCode.VALIDATION_FAILED
@@ -14029,7 +14256,7 @@ var WorkflowService = class extends BaseService {
     };
     const validationResult = WorkflowDefinitionSchema.safeParse(updated);
     if (!validationResult.success) {
-      const errors = validationResult.error.issues.map((i) => i.message);
+      const errors = formatZodErrors(validationResult.error).map((err) => err.message);
       throw new SchemaError(
         `Invalid workflow definition: ${errors.join(", ")}`,
         SchemaErrorCode.VALIDATION_FAILED
@@ -14058,7 +14285,7 @@ var WorkflowService = class extends BaseService {
     }
     const validationResult = WorkflowDefinitionSchema.safeParse(existing);
     if (!validationResult.success) {
-      const errors = validationResult.error.issues.map((i) => i.message);
+      const errors = formatZodErrors(validationResult.error).map((err) => err.message);
       throw new SchemaError(
         `Cannot publish invalid workflow: ${errors.join(", ")}`,
         SchemaErrorCode.VALIDATION_FAILED
@@ -15143,7 +15370,7 @@ var DocumentService = class extends BaseService {
     const template = await this.templateService.getTemplateOrThrow(document2.templateId);
     const slots = await this.getSlots(documentId);
     const requiredSlots = template.slots.filter((s) => s.required);
-    const filledSlotNames = new Set(slots.map((s) => s.slotName));
+    const filledSlotNames = slots.reduce((set, s) => set.add(s.slotName), /* @__PURE__ */ new Set());
     const allRequiredFilled = requiredSlots.every((s) => filledSlotNames.has(s.name));
     if (!allRequiredFilled) {
       return await this.updateStatus(documentId, "draft");
@@ -16717,7 +16944,7 @@ var PermissionService = class extends BaseService {
       DEFAULT_ROLE_PERMISSIONS
     } = await import("./default-roles-42X3TJI5.mjs");
     const existingRoles = await this.getRoles();
-    const existingRoleNames = new Set(existingRoles.map((r) => r.name));
+    const existingRoleNames = existingRoles.reduce((set, r) => set.add(r.name), /* @__PURE__ */ new Set());
     for (const roleName of Object.values(DEFAULT_ROLES)) {
       if (existingRoleNames.has(roleName)) {
         continue;
@@ -17211,7 +17438,7 @@ var ViewService = class extends BaseService {
    */
   async hasUserCustomizations(viewId, userId) {
     const overlay = await this.adapter.viewOverlays.findByViewAndUser(viewId, userId);
-    return overlay !== null && Object.keys(overlay.configOverrides).length > 0;
+    return overlay !== null && hasProperties(overlay.configOverrides);
   }
   // ============================================================================
   // OVERLAY MERGE LOGIC
@@ -17586,8 +17813,9 @@ async function handleDryRun(adapter, nativeObject, existingObject, result, optio
   if (options.verbose) {
     console.info(`[SyncService] Would ${isNew ? "create" : "update"} object: ${nativeObject.name}`);
   }
+  const existingAttrs = existingObject ? await adapter.attributes.findByObjectId(existingObject.id) : [];
   for (const attr of nativeObject.attributes) {
-    const existingAttr = existingObject ? await adapter.attributes.findByObjectId(existingObject.id).then((attrs) => attrs.find((a) => a.name === attr.name)) : null;
+    const existingAttr = existingAttrs.find((a) => a.name === attr.name) ?? null;
     if (existingAttr) {
       result.attributesUpdated++;
     } else {
@@ -17609,8 +17837,9 @@ async function upsertObject(adapter, nativeObject, _options) {
   });
 }
 async function syncAttributes(adapter, nativeObject, dbObject, existingObject, result) {
+  const existingAttrs = existingObject ? await adapter.attributes.findByObjectId(dbObject.id) : [];
   for (const [index, attr] of nativeObject.attributes.entries()) {
-    const existingAttr = existingObject ? await adapter.attributes.findByObjectId(dbObject.id).then((attrs) => attrs.find((a) => a.name === attr.name)) : null;
+    const existingAttr = existingAttrs.find((a) => a.name === attr.name) ?? null;
     await adapter.attributes.upsert({
       objectId: dbObject.id,
       name: attr.name,
@@ -17704,8 +17933,6 @@ export {
   isIdentityProperty,
   isBehaviorProperty,
   isPresentationProperty,
-  getPropertyProtectionLevel,
-  filterPropertiesByCategory,
   RELATION_TARGET_ANY,
   isUniversalRelation,
   RecordReferencedError,
@@ -17715,6 +17942,7 @@ export {
   SYSTEM_FIELD_NAMES,
   RESERVED_ATTRIBUTE_NAMES,
   PolicyViolationError,
+  FORBIDDEN_PROPERTY_TYPES,
   SYSTEM_ATTRIBUTES,
   getSystemAttributeList,
   isSystemAttribute,
@@ -17734,8 +17962,6 @@ export {
   and,
   or,
   inValues,
-  isEmpty,
-  isNotEmpty,
   isWorkflowDefinition,
   isWorkflowPublished,
   isSystemWorkflow,
@@ -17754,7 +17980,6 @@ export {
   createEmptyContext,
   getContextValue,
   setContextValue,
-  mergeFormToSlot,
   DEFAULT_THEME,
   mergeWithDefaults,
   generateCssVariables,
@@ -17788,12 +18013,10 @@ export {
   WorkflowConfigSchema,
   WorkflowStatusSchema,
   WorkflowDefinitionSchema,
-  asTenantId,
-  asUserId,
-  generateId,
-  generatePrefixedId,
-  slugify,
-  generateTemplateName,
+  isEmpty,
+  isNotEmpty,
+  toUndefinedIfEmpty,
+  hasProperties,
   EMPTY_VALUE_PLACEHOLDER,
   formatAttributeValue,
   SchemaErrorCode,
@@ -17818,7 +18041,22 @@ export {
   RoleNotFoundError,
   isForbiddenError,
   ConcurrentModificationError,
-  isConcurrentModificationError,
+  PropertySchemaBuilder,
+  PropertyTypeBuilder,
+  BasePropertyBuilder,
+  TextPropertyBuilder,
+  TextareaPropertyBuilder,
+  NumberPropertyBuilder,
+  CheckboxPropertyBuilder,
+  DatePropertyBuilder,
+  PhonePropertyBuilder,
+  CurrencyPropertyBuilder,
+  StatusPropertyBuilder,
+  SelectPropertyBuilder,
+  MultiselectPropertyBuilder,
+  RatingPropertyBuilder,
+  LocationPropertyBuilder,
+  validatePropertyType,
   text,
   textarea,
   richtext,
@@ -17876,63 +18114,6 @@ export {
   SYSTEM_TEMPLATES,
   getSystemTemplate,
   isSystemTemplate,
-  DEFAULT_VALIDATION_MESSAGES,
-  textConfigSchema,
-  textareaConfigSchema,
-  richtextConfigSchema,
-  numberConfigSchema,
-  checkboxConfigSchema,
-  dateConfigSchema,
-  phoneConfigSchema,
-  currencyConfigSchema,
-  statusConfigSchema,
-  locationConfigSchema,
-  selectConfigSchema,
-  multiselectConfigSchema,
-  fileConfigSchema,
-  userConfigSchema,
-  relationConfigSchema,
-  ratingConfigSchema,
-  formulaConfigSchema,
-  rollupConfigSchema,
-  documentConfigSchema,
-  attributeConfigSchemas,
-  getAttributeConfigSchema,
-  validateAttributeConfig,
-  parseAttributeConfig,
-  safeParseAttributeConfig,
-  createTextValidator,
-  createNumberValidator,
-  createCheckboxValidator,
-  createDateValidator,
-  createPhoneValidator,
-  createCurrencyValidator,
-  createStatusValidator,
-  createSelectValidator,
-  createMultiselectValidator,
-  createLocationValidator,
-  createFileValidator,
-  createUserValidator,
-  createSingleRelationValidator,
-  createMultiRelationValidator,
-  createRelationValidator,
-  createRatingValidator,
-  createFormulaValidator,
-  createRollupValidator,
-  createTextAreaValidator,
-  createRichtextValidator,
-  createAttributeValidator,
-  createFormAttributeValidator,
-  createObjectValidator,
-  validateAttribute,
-  validateObject,
-  validateObjectOrThrow,
-  createDraftValidator,
-  validateDraft,
-  validateDraftOrThrow,
-  getMissingRequiredAttributes,
-  isRecordComplete,
-  computeRecordStatus,
   WorkflowJwtService,
   hashOptions,
   cacheKeys,
@@ -18045,6 +18226,7 @@ export {
   recalculateParentRollups,
   RecordQueryService,
   RecordResolverService,
+  RelationPropertiesService,
   RelationService,
   RollupService,
   RecordService,