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

package/dist/index.js

@@ -129,8 +129,13 @@ __export(index_exports, {
   DEFAULT_ROLE_LABELS: () => DEFAULT_ROLE_LABELS,
   DEFAULT_ROLE_PERMISSIONS: () => DEFAULT_ROLE_PERMISSIONS,
   DuplicateError: () => DuplicateError,
+  EMPTY_VALUE_PLACEHOLDER: () => EMPTY_VALUE_PLACEHOLDER,
   FileNotFoundError: () => FileNotFoundError,
   FileService: () => FileService,
+  FlowBuilder: () => FlowBuilder,
+  FlowPageBuilder: () => FlowPageBuilder,
+  FlowRowBuilder: () => FlowRowBuilder,
+  FlowService: () => FlowService,
   ForbiddenError: () => ForbiddenError,
   GeocodingService: () => GeocodingService,
   GlobalSearchService: () => GlobalSearchService,
@@ -195,9 +200,12 @@ __export(index_exports, {
   currencyConfigSchema: () => currencyConfigSchema,
   date: () => date,
   dateConfigSchema: () => dateConfigSchema,
+  enrichValuesWithSelectLabels: () => enrichValuesWithSelectLabels,
   extractAttributeNames: () => extractAttributeNames,
   file: () => file,
   fileConfigSchema: () => fileConfigSchema,
+  flow: () => flow,
+  formatAttributeValue: () => formatAttributeValue,
   generateId: () => generateId,
   generatePrefixedId: () => generatePrefixedId,
   getAttributeConfigSchema: () => getAttributeConfigSchema,
@@ -205,9 +213,12 @@ __export(index_exports, {
   getSyncPreview: () => getSyncPreview,
   getViewSyncPreview: () => getViewSyncPreview,
   group: () => group,
+  isActivityTab: () => isActivityTab,
   isAdvancedFilterState: () => isAdvancedFilterState,
   isCustomTab: () => isCustomTab,
   isDefaultRole: () => isDefaultRole,
+  isFlowDefinition: () => isFlowDefinition,
+  isFlowPublished: () => isFlowPublished,
   isForbiddenError: () => isForbiddenError,
   isFormTab: () => isFormTab,
   isLabelExpression: () => isLabelExpression,
@@ -216,6 +227,7 @@ __export(index_exports, {
   isProtectedResourceError: () => isProtectedResourceError,
   isRecordComplete: () => isRecordComplete,
   isSchemaError: () => isSchemaError,
+  isSystemFlow: () => isSystemFlow,
   isTableTab: () => isTableTab,
   isValidationError: () => isValidationError,
   location: () => location,
@@ -392,6 +404,17 @@ function isNoValueOperator(operator) {
   return NO_VALUE_OPERATORS.includes(operator);
 }
 
+// src/types/flows.ts
+function isFlowDefinition(obj) {
+  return typeof obj === "object" && obj !== null && "slots" in obj && "pages" in obj && "relations" in obj && "status" in obj;
+}
+function isFlowPublished(flow2) {
+  return flow2.status === "published";
+}
+function isSystemFlow(flow2) {
+  return flow2.system === true;
+}
+
 // src/types/geocoding.ts
 var NoopGeocodingAdapter = class {
   async autocomplete() {
@@ -415,6 +438,9 @@ function isTableTab(tab) {
 function isCustomTab(tab) {
   return tab.type === "custom";
 }
+function isActivityTab(tab) {
+  return tab.type === "activity";
+}
 
 // src/utils.ts
 function generateId() {
@@ -431,6 +457,168 @@ function generatePrefixedId(prefix) {
   return `${prefix}_${generateId()}`;
 }
 
+// src/format.ts
+var import_constants = require("@stndrds/constants");
+var EMPTY_VALUE_PLACEHOLDER = "\u2014";
+function formatText(value) {
+  return String(value);
+}
+function formatCheckbox(value) {
+  return value ? "Yes" : "No";
+}
+function formatNumber(value, attribute) {
+  if (typeof value !== "number") return String(value);
+  const decimals = attribute.decimals;
+  return value.toLocaleString(void 0, {
+    minimumFractionDigits: decimals,
+    maximumFractionDigits: decimals
+  });
+}
+function formatCurrency(value, _attribute) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const currency2 = value;
+  if (!("value" in currency2 && "code" in currency2)) return String(value);
+  const formattedValue = currency2.value.toLocaleString(void 0, {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+  return `${formattedValue} ${currency2.code}`;
+}
+function formatDate(value) {
+  if (value instanceof Date) {
+    return value.toISOString().split("T")[0];
+  }
+  if (typeof value === "string") {
+    const date2 = new Date(value);
+    if (!Number.isNaN(date2.getTime())) {
+      return date2.toISOString().split("T")[0];
+    }
+  }
+  return String(value);
+}
+function formatTimestamp(value) {
+  if (typeof value === "number") {
+    return new Date(value).toISOString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  return String(value);
+}
+function formatPhone(value) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const phone2 = value;
+  if (!("phoneNumber" in phone2)) return String(value);
+  if (phone2.countryCode) {
+    const country = (0, import_constants.getCountryByIso3)(phone2.countryCode);
+    const dial = country?.phoneCode ?? "";
+    return `${dial} ${phone2.phoneNumber}`.trim();
+  }
+  return phone2.phoneNumber;
+}
+function formatLocation(value, attribute) {
+  if (typeof value !== "object" || value === null) return String(value);
+  const loc = value;
+  const granularity = attribute.granularity ?? "full";
+  const parts = [];
+  switch (granularity) {
+    case "country":
+      if (loc.country) parts.push(loc.country);
+      break;
+    case "state":
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(loc.country);
+      break;
+    case "city":
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(loc.country);
+      break;
+    case "coordinates":
+      if (loc.latitude !== void 0 && loc.longitude !== void 0) {
+        parts.push(`${loc.latitude}, ${loc.longitude}`);
+      }
+      break;
+    case "address":
+      if (loc.address) parts.push(loc.address);
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.country) parts.push(loc.country);
+      break;
+    default:
+      if (loc.address) parts.push(loc.address);
+      if (loc.city) parts.push(loc.city);
+      if (loc.state) parts.push(loc.state);
+      if (loc.postalCode) parts.push(loc.postalCode);
+      if (loc.country) parts.push(loc.country);
+      break;
+  }
+  return parts.join(", ") || EMPTY_VALUE_PLACEHOLDER;
+}
+function formatSelect(value, attribute) {
+  if (typeof value !== "string") return String(value);
+  const option = attribute.options?.find((o) => o.value === value);
+  return option?.label ?? String(value);
+}
+function formatMultiselect(value, attribute) {
+  if (!Array.isArray(value)) return String(value);
+  if (attribute.options) {
+    const labels = value.map((v) => attribute.options.find((o) => o.value === v)?.label).filter(Boolean);
+    return labels.join(", ");
+  }
+  return value.join(", ");
+}
+function formatRating(value, attribute) {
+  if (typeof value !== "number") return String(value);
+  const max = attribute.max ?? 5;
+  return `${value}/${max}`;
+}
+function formatAttributeValue(value, attribute) {
+  if (value === null || value === void 0 || value === "") {
+    return EMPTY_VALUE_PLACEHOLDER;
+  }
+  switch (attribute.type) {
+    case "text":
+    case "textarea":
+      return formatText(value);
+    case "checkbox":
+      return formatCheckbox(value);
+    case "number":
+      return formatNumber(value, attribute);
+    case "currency":
+      return formatCurrency(value, attribute);
+    case "date":
+      return formatDate(value);
+    case "timestamp":
+      return formatTimestamp(value);
+    case "phone":
+      return formatPhone(value);
+    case "location":
+      return formatLocation(value, attribute);
+    case "select":
+    case "status":
+      return formatSelect(value, attribute);
+    case "multiselect":
+      return formatMultiselect(value, attribute);
+    case "rating":
+      return formatRating(value, attribute);
+    // Unsupported types - return value as-is or placeholder
+    case "file":
+    case "user":
+    case "relation":
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    default: {
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    }
+  }
+}
+
 // src/constants/index.ts
 init_default_roles();
 
@@ -634,8 +822,8 @@ function isForbiddenError(error) {
 }
 
 // src/builders/attribute-validators.ts
-var import_constants = require("@stndrds/constants");
-var VALID_ICONS = new Set(import_constants.ICONS);
+var import_constants2 = require("@stndrds/constants");
+var VALID_ICONS = new Set(import_constants2.ICONS);
 var ATTRIBUTE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
 var MAX_NAME_LENGTH = 63;
 var MAX_LABEL_LENGTH = 128;
@@ -1284,8 +1472,361 @@ function rating(config) {
   return new RatingAttributeBuilder(config.name, config.label);
 }
 
+// src/builders/flow-builder.ts
+var import_zod = require("zod");
+var FlowRowBuilder = class {
+  /** @internal */
+  constructor(pageBuilder, id, order) {
+    this.pageBuilder = pageBuilder;
+    this.rowData = {
+      id,
+      order,
+      fields: []
+    };
+  }
+  /**
+   * Add a field to the current row
+   *
+   * @param slotId - Reference to a slot defined with .slot()
+   * @param attribute - Attribute name on the object
+   * @param options - Optional field configuration
+   *
+   * @example
+   * ```typescript
+   * .row("row-1")
+   *   .field("mr", "firstName")
+   *   .field("mr", "lastName")
+   * ```
+   */
+  field(slotId, attribute, options) {
+    const field = {
+      id: `${this.rowData.id}-${slotId}-${attribute}`,
+      slotId,
+      attribute,
+      label: options?.label,
+      required: options?.required
+    };
+    this.rowData.fields.push(field);
+    return this;
+  }
+  /**
+   * Start a new row on the same page
+   */
+  row(id) {
+    return this.pageBuilder._finalizeRow(this.rowData).row(id);
+  }
+  /**
+   * Start a new page
+   */
+  page(id, label, description) {
+    return this.pageBuilder._finalizeRow(this.rowData)._getFlow().page(id, label, description);
+  }
+  /**
+   * Build the final flow definition
+   */
+  build() {
+    return this.pageBuilder._finalizeRow(this.rowData)._getFlow().build();
+  }
+};
+var FlowPageBuilder = class {
+  /** @internal */
+  constructor(flow2, id, label, description) {
+    this.rowOrder = 0;
+    this.flow = flow2;
+    this.pageData = {
+      id,
+      label,
+      description,
+      order: 0,
+      // Will be set when finalized
+      rows: []
+    };
+  }
+  /**
+   * Add a row to the current page
+   *
+   * @param id - Unique row identifier
+   *
+   * @example
+   * ```typescript
+   * .page("identity", "Identité")
+   *   .row("name-row")
+   *     .field("mr", "firstName")
+   *     .field("mr", "lastName")
+   *   .row("email-row")
+   *     .field("mr", "email")
+   * ```
+   */
+  row(id) {
+    this.rowOrder++;
+    return new FlowRowBuilder(this, id, this.rowOrder);
+  }
+  /**
+   * Start a new page
+   */
+  page(id, label, description) {
+    return this.flow._finalizePage(this.pageData).page(id, label, description);
+  }
+  /**
+   * Build the final flow definition
+   */
+  build() {
+    return this.flow._finalizePage(this.pageData).build();
+  }
+  /** @internal */
+  _finalizeRow(row) {
+    if (row.id && row.fields.length > 0) {
+      this.pageData.rows?.push(row);
+    }
+    return this;
+  }
+  /** @internal */
+  _getFlow() {
+    return this.flow._finalizePage(this.pageData);
+  }
+  /** @internal */
+  _getPageData() {
+    return this.pageData;
+  }
+};
+var FlowBuilder = class {
+  constructor(name, label) {
+    this.data = {
+      slots: [],
+      pages: [],
+      relations: [],
+      status: "published",
+      // System flows are always published
+      version: 1,
+      system: true
+    };
+    this.validateName(name);
+    this.data.name = name;
+    this.data.label = label;
+  }
+  /**
+   * Set flow description
+   */
+  description(value) {
+    this.data.description = value;
+    return this;
+  }
+  /**
+   * Set flow icon
+   */
+  icon(value) {
+    this.data.icon = value;
+    return this;
+  }
+  /**
+   * Set extensible metadata
+   */
+  metadata(value) {
+    this.data.metadata = value;
+    return this;
+  }
+  /**
+   * Add a slot (object to create in the flow)
+   *
+   * @param id - Unique slot identifier (used to reference in fields and relations)
+   * @param objectName - Name of the object to create
+   * @param label - Display label for the slot
+   * @param options - Optional slot configuration
+   *
+   * @example
+   * ```typescript
+   * .slot("mr", "contacts", "Monsieur", { color: "blue", icon: "user" })
+   * .slot("company", "companies", "Entreprise", { color: "green" })
+   * ```
+   */
+  slot(id, objectName, label, options) {
+    if (this.data.slots?.some((s) => s.id === id)) {
+      throw new Error(`[FlowBuilder] Duplicate slot id: "${id}"`);
+    }
+    this.data.slots?.push({
+      id,
+      objectName,
+      label,
+      color: options?.color,
+      icon: options?.icon
+    });
+    return this;
+  }
+  /**
+   * Define a relation between two slots
+   * The source slot will be linked to the target slot via the specified attribute
+   *
+   * @param sourceSlotId - Slot that has the relation attribute
+   * @param sourceAttribute - Relation attribute name on the source
+   * @param targetSlotId - Target slot to link to
+   *
+   * @example
+   * ```typescript
+   * // mr.company → company (the contact's company field will be set to the created company)
+   * .relation("mr", "company", "company")
+   * ```
+   */
+  relation(sourceSlotId, sourceAttribute, targetSlotId) {
+    this.data.relations?.push({
+      id: `${sourceSlotId}-${sourceAttribute}-${targetSlotId}`,
+      sourceSlotId,
+      sourceAttribute,
+      targetSlotId
+    });
+    return this;
+  }
+  /**
+   * Start a new page/step in the flow
+   *
+   * @param id - Unique page identifier
+   * @param label - Display label
+   * @param description - Optional description
+   *
+   * @example
+   * ```typescript
+   * .page("identity", "Identité", "Informations personnelles")
+   *   .row("name")
+   *     .field("mr", "firstName")
+   *     .field("mr", "lastName")
+   * ```
+   */
+  page(id, label, description) {
+    return new FlowPageBuilder(this, id, label, description);
+  }
+  /**
+   * Build and validate the flow definition
+   *
+   * @throws Error if validation fails
+   */
+  build() {
+    this.validateRequiredData();
+    const slotIds = new Set(this.data.slots?.map((s) => s.id) ?? []);
+    this.validateFieldReferences(slotIds);
+    this.validateRelationReferences(slotIds);
+    this.validateNoCircularDependencies();
+    return this.data;
+  }
+  /**
+   * Validate that required data is present
+   */
+  validateRequiredData() {
+    if (!this.data.slots || this.data.slots.length === 0) {
+      throw new Error("[FlowBuilder] At least one slot is required. Use .slot() to add slots.");
+    }
+    if (!this.data.pages || this.data.pages.length === 0) {
+      throw new Error("[FlowBuilder] At least one page is required. Use .page() to add pages.");
+    }
+  }
+  /**
+   * Validate that all field slotId references exist
+   */
+  validateFieldReferences(slotIds) {
+    for (const page of this.data.pages ?? []) {
+      for (const row of page.rows) {
+        for (const field of row.fields) {
+          if (!slotIds.has(field.slotId)) {
+            throw new Error(
+              `[FlowBuilder] Field "${field.id}" references unknown slot "${field.slotId}" in page "${page.id}". Available slots: ${[...slotIds].join(", ")}`
+            );
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Validate that all relation references exist and are valid
+   */
+  validateRelationReferences(slotIds) {
+    for (const relation2 of this.data.relations ?? []) {
+      if (!slotIds.has(relation2.sourceSlotId)) {
+        throw new Error(
+          `[FlowBuilder] Relation references unknown source slot "${relation2.sourceSlotId}". Available slots: ${[...slotIds].join(", ")}`
+        );
+      }
+      if (!slotIds.has(relation2.targetSlotId)) {
+        throw new Error(
+          `[FlowBuilder] Relation references unknown target slot "${relation2.targetSlotId}". Available slots: ${[...slotIds].join(", ")}`
+        );
+      }
+      if (relation2.sourceSlotId === relation2.targetSlotId) {
+        throw new Error(
+          `[FlowBuilder] Relation cannot link a slot to itself: "${relation2.sourceSlotId}"`
+        );
+      }
+    }
+  }
+  /**
+   * @internal Used by FlowPageBuilder to finalize a page
+   */
+  _finalizePage(page) {
+    if (page.id) {
+      page.order = (this.data.pages?.length ?? 0) + 1;
+      this.data.pages?.push(page);
+    }
+    return this;
+  }
+  /**
+   * Validate flow name format (kebab-case)
+   */
+  validateName(name) {
+    const flowNameSchema = import_zod.z.string().min(1, "Flow name cannot be empty").max(63, "Flow name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+      message: "Invalid flow name format.\nName must be in kebab-case:\n  \u2705 Valid: 'couple-creation', 'new-contact', 'onboarding-flow'\n  \u274C Invalid: 'CoupleCreation', 'new_contact', 'Onboarding Flow'"
+    });
+    try {
+      flowNameSchema.parse(name);
+    } catch (error) {
+      if (error instanceof import_zod.z.ZodError) {
+        throw new Error(`[FlowBuilder] ${error.issues[0].message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate that there are no circular dependencies in relations
+   * Uses DFS to detect cycles in the dependency graph
+   */
+  validateNoCircularDependencies() {
+    const relations = this.data.relations ?? [];
+    if (relations.length === 0) return;
+    const dependsOn = /* @__PURE__ */ new Map();
+    for (const slot of this.data.slots ?? []) {
+      dependsOn.set(slot.id, /* @__PURE__ */ new Set());
+    }
+    for (const rel of relations) {
+      dependsOn.get(rel.sourceSlotId)?.add(rel.targetSlotId);
+    }
+    const visited = /* @__PURE__ */ new Set();
+    const recursionStack = /* @__PURE__ */ new Set();
+    const hasCycle = (slotId) => {
+      visited.add(slotId);
+      recursionStack.add(slotId);
+      for (const dependency of dependsOn.get(slotId) ?? []) {
+        if (!visited.has(dependency)) {
+          if (hasCycle(dependency)) return true;
+        } else if (recursionStack.has(dependency)) {
+          return true;
+        }
+      }
+      recursionStack.delete(slotId);
+      return false;
+    };
+    for (const slot of this.data.slots ?? []) {
+      if (!visited.has(slot.id)) {
+        if (hasCycle(slot.id)) {
+          throw new Error(
+            "[FlowBuilder] Circular dependency detected in relations. Slots cannot have circular dependencies."
+          );
+        }
+      }
+    }
+  }
+};
+function flow(name, label) {
+  return new FlowBuilder(name, label);
+}
+
 // src/builders/object-builder.ts
-var import_zod = __toESM(require("zod"));
+var import_zod2 = __toESM(require("zod"));
 var ObjectBuilder = class {
   constructor(config) {
     this.validateName(config.name);
@@ -1418,14 +1959,14 @@ The labelExpression defines how records are displayed in lists and relations.
     if (name === void 0) {
       return;
     }
-    const objectNameSchema = import_zod.default.string().min(1, "Object name cannot be empty").max(63, "Object name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+    const objectNameSchema = import_zod2.default.string().min(1, "Object name cannot be empty").max(63, "Object name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
       message: "Invalid object name format.\nName must be in kebab-case (slug format):\n  \u2705 Valid: 'products', 'user-profiles', 'order-items'\n  \u274C Invalid: 'Products', 'userProfiles', 'user_profiles'"
     });
     try {
       objectNameSchema.parse(name);
     } catch (error) {
-      if (error instanceof import_zod.default.ZodError) {
-        throw new Error(`[ObjectBuilder] ${error.errors[0].message}`);
+      if (error instanceof import_zod2.default.ZodError) {
+        throw new Error(`[ObjectBuilder] ${error.issues[0].message}`);
       }
       throw error;
     }
@@ -1436,7 +1977,7 @@ function object(config) {
 }
 
 // src/builders/view-builder.ts
-var import_zod2 = require("zod");
+var import_zod3 = require("zod");
 var GroupBuilder = class {
   constructor(id, label) {
     this.data = { fields: [] };
@@ -1792,14 +2333,14 @@ var ViewBuilder = class {
    * Validate view name format (kebab-case)
    */
   validateName(name) {
-    const viewNameSchema = import_zod2.z.string().min(1, "View name cannot be empty").max(63, "View name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+    const viewNameSchema = import_zod3.z.string().min(1, "View name cannot be empty").max(63, "View name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
       message: "Invalid view name format.\nName must be in kebab-case:\n  \u2705 Valid: 'detail', 'list-view', 'company-detail'\n  \u274C Invalid: 'Detail', 'listView', 'list_view'"
     });
     try {
       viewNameSchema.parse(name);
     } catch (error) {
-      if (error instanceof import_zod2.z.ZodError) {
-        throw new Error(`[ViewBuilder] ${error.errors[0].message}`);
+      if (error instanceof import_zod3.z.ZodError) {
+        throw new Error(`[ViewBuilder] ${error.issues[0].message}`);
       }
       throw error;
     }
@@ -2097,35 +2638,42 @@ Available views: ${availableNames}`
 var viewRegistry = new ViewRegistry();
 
 // src/validation/validators.ts
-var import_zod3 = require("zod");
-var baseConfigSchema = import_zod3.z.object({
-  disabled: import_zod3.z.boolean().optional(),
-  placeholder: import_zod3.z.string().optional(),
-  description: import_zod3.z.string().optional(),
-  defaultValue: import_zod3.z.unknown().optional(),
-  icon: import_zod3.z.string().optional(),
-  order: import_zod3.z.number().int().optional(),
-  hidden: import_zod3.z.boolean().optional(),
-  archived: import_zod3.z.boolean().optional(),
-  deprecated: import_zod3.z.boolean().optional(),
-  metadata: import_zod3.z.record(import_zod3.z.unknown()).optional()
+var import_zod4 = require("zod");
+var baseConfigSchema = import_zod4.z.object({
+  disabled: import_zod4.z.boolean().optional(),
+  placeholder: import_zod4.z.string().optional(),
+  description: import_zod4.z.string().optional(),
+  defaultValue: import_zod4.z.unknown().optional(),
+  icon: import_zod4.z.string().optional(),
+  order: import_zod4.z.number().int().optional(),
+  hidden: import_zod4.z.boolean().optional(),
+  archived: import_zod4.z.boolean().optional(),
+  deprecated: import_zod4.z.boolean().optional(),
+  metadata: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
 });
-var optionSchema = import_zod3.z.object({
-  id: import_zod3.z.string().min(1),
-  label: import_zod3.z.string().min(1),
-  value: import_zod3.z.string().min(1),
-  color: import_zod3.z.string().optional(),
-  icon: import_zod3.z.string().optional(),
-  description: import_zod3.z.string().optional(),
-  group: import_zod3.z.enum(["idle", "in_progress", "finished"]).optional()
+var optionSchema = import_zod4.z.object({
+  id: import_zod4.z.string().min(1),
+  label: import_zod4.z.string().min(1),
+  value: import_zod4.z.string().min(1),
+  color: import_zod4.z.string().optional(),
+  icon: import_zod4.z.string().optional(),
+  description: import_zod4.z.string().optional(),
+  group: import_zod4.z.enum(["idle", "in_progress", "finished"]).optional()
 });
-var relationTargetSchema = import_zod3.z.object({
-  object: import_zod3.z.string().min(1),
-  displayTemplate: import_zod3.z.string().optional(),
-  filter: import_zod3.z.record(import_zod3.z.unknown()).optional()
+var optionsArraySchema = import_zod4.z.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 = import_zod4.z.object({
+  object: import_zod4.z.string().min(1),
+  displayTemplate: import_zod4.z.string().optional(),
+  filter: import_zod4.z.record(import_zod4.z.string(), import_zod4.z.unknown()).optional()
 });
-var documentTypeConfigSchema = import_zod3.z.object({
-  type: import_zod3.z.enum([
+var documentTypeConfigSchema = import_zod4.z.object({
+  type: import_zod4.z.enum([
     "id_card",
     "passport",
     "incorporation_certificate",
@@ -2136,86 +2684,86 @@ var documentTypeConfigSchema = import_zod3.z.object({
     "proof_of_address",
     "custom"
   ]),
-  label: import_zod3.z.string(),
-  faces: import_zod3.z.array(import_zod3.z.enum(["front", "back", "single"])),
-  attributeMapping: import_zod3.z.array(
-    import_zod3.z.object({
-      attributeId: import_zod3.z.string(),
-      extractedKey: import_zod3.z.string(),
-      face: import_zod3.z.enum(["front", "back", "single"]).optional(),
-      required: import_zod3.z.boolean().optional()
+  label: import_zod4.z.string(),
+  faces: import_zod4.z.array(import_zod4.z.enum(["front", "back", "single"])),
+  attributeMapping: import_zod4.z.array(
+    import_zod4.z.object({
+      attributeId: import_zod4.z.string(),
+      extractedKey: import_zod4.z.string(),
+      face: import_zod4.z.enum(["front", "back", "single"]).optional(),
+      required: import_zod4.z.boolean().optional()
     })
   ).optional()
 });
-var fileVerificationConfigSchema = import_zod3.z.object({
-  enabled: import_zod3.z.boolean(),
-  documentTypes: import_zod3.z.array(documentTypeConfigSchema),
-  autoExtract: import_zod3.z.boolean().optional(),
-  autoValidate: import_zod3.z.boolean().optional()
+var fileVerificationConfigSchema = import_zod4.z.object({
+  enabled: import_zod4.z.boolean(),
+  documentTypes: import_zod4.z.array(documentTypeConfigSchema),
+  autoExtract: import_zod4.z.boolean().optional(),
+  autoValidate: import_zod4.z.boolean().optional()
 });
 var textConfigSchema = baseConfigSchema.extend({
-  minLength: import_zod3.z.number().int().min(0).optional(),
-  maxLength: import_zod3.z.number().int().min(1).optional(),
-  pattern: import_zod3.z.string().optional()
+  minLength: import_zod4.z.number().int().min(0).optional(),
+  maxLength: import_zod4.z.number().int().min(1).optional(),
+  pattern: import_zod4.z.string().optional()
 });
 var textareaConfigSchema = baseConfigSchema;
 var numberConfigSchema = baseConfigSchema.extend({
-  min: import_zod3.z.number().optional(),
-  max: import_zod3.z.number().optional(),
-  unit: import_zod3.z.enum(["integer", "decimal", "percentage"]).optional(),
-  decimals: import_zod3.z.number().int().min(0).optional()
+  min: import_zod4.z.number().optional(),
+  max: import_zod4.z.number().optional(),
+  unit: import_zod4.z.enum(["integer", "decimal", "percentage"]).optional(),
+  decimals: import_zod4.z.number().int().min(0).optional()
 });
 var checkboxConfigSchema = baseConfigSchema;
 var dateConfigSchema = baseConfigSchema.extend({
-  dateFormat: import_zod3.z.enum(["short", "long", "full", "relative"]).optional(),
-  minDate: import_zod3.z.string().optional(),
-  maxDate: import_zod3.z.string().optional()
+  dateFormat: import_zod4.z.enum(["short", "long", "full", "relative"]).optional(),
+  minDate: import_zod4.z.string().optional(),
+  maxDate: import_zod4.z.string().optional()
 });
 var phoneConfigSchema = baseConfigSchema.extend({
-  defaultCountryCode: import_zod3.z.string().length(3).optional()
+  defaultCountryCode: import_zod4.z.string().length(3).optional()
 });
 var currencyConfigSchema = baseConfigSchema.extend({
-  defaultCurrency: import_zod3.z.string().length(3).optional(),
-  allowedCurrencies: import_zod3.z.array(import_zod3.z.string().length(3)).optional()
+  defaultCurrency: import_zod4.z.string().length(3).optional(),
+  allowedCurrencies: import_zod4.z.array(import_zod4.z.string().length(3)).optional()
 });
 var statusConfigSchema = baseConfigSchema.extend({
-  options: import_zod3.z.array(optionSchema).min(1)
+  options: optionsArraySchema
 });
 var locationConfigSchema = baseConfigSchema.extend({
-  granularity: import_zod3.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
-  enableAutocomplete: import_zod3.z.boolean().optional(),
-  enableMap: import_zod3.z.boolean().optional(),
-  defaultCountry: import_zod3.z.string().length(3).optional(),
-  allowedCountries: import_zod3.z.array(import_zod3.z.string().length(3)).optional(),
-  displayFormat: import_zod3.z.enum(["single_line", "multi_line", "compact"]).optional()
+  granularity: import_zod4.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
+  enableAutocomplete: import_zod4.z.boolean().optional(),
+  enableMap: import_zod4.z.boolean().optional(),
+  defaultCountry: import_zod4.z.string().length(3).optional(),
+  allowedCountries: import_zod4.z.array(import_zod4.z.string().length(3)).optional(),
+  displayFormat: import_zod4.z.enum(["single_line", "multi_line", "compact"]).optional()
 });
 var timestampConfigSchema = baseConfigSchema.extend({
-  autoUpdate: import_zod3.z.boolean().optional()
+  autoUpdate: import_zod4.z.boolean().optional()
 });
 var selectConfigSchema = baseConfigSchema.extend({
-  options: import_zod3.z.array(optionSchema).min(1)
+  options: optionsArraySchema
 });
 var multiselectConfigSchema = baseConfigSchema.extend({
-  options: import_zod3.z.array(optionSchema).min(1)
+  options: optionsArraySchema
 });
 var fileConfigSchema = baseConfigSchema.extend({
-  maxFiles: import_zod3.z.number().int().min(1).optional(),
-  maxSize: import_zod3.z.number().int().min(1).optional(),
-  allowedTypes: import_zod3.z.array(import_zod3.z.string()).optional(),
+  maxFiles: import_zod4.z.number().int().min(1).optional(),
+  maxSize: import_zod4.z.number().int().min(1).optional(),
+  allowedTypes: import_zod4.z.array(import_zod4.z.string()).optional(),
   verification: fileVerificationConfigSchema.optional()
 });
 var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: import_zod3.z.array(import_zod3.z.string()).optional()
+  allowedRoles: import_zod4.z.array(import_zod4.z.string()).optional()
 });
 var relationConfigSchema = baseConfigSchema.extend({
-  targets: import_zod3.z.array(relationTargetSchema).min(1),
-  cardinality: import_zod3.z.enum(["one", "many"]),
-  minItems: import_zod3.z.number().int().min(0).optional(),
-  maxItems: import_zod3.z.number().int().min(1).optional()
+  targets: import_zod4.z.array(relationTargetSchema).min(1),
+  cardinality: import_zod4.z.enum(["one", "many"]),
+  minItems: import_zod4.z.number().int().min(0).optional(),
+  maxItems: import_zod4.z.number().int().min(1).optional()
 });
 var ratingConfigSchema = baseConfigSchema.extend({
-  max: import_zod3.z.number().int().min(1).optional(),
-  iconType: import_zod3.z.enum(["star", "heart", "thumbs", "number"]).optional()
+  max: import_zod4.z.number().int().min(1).optional(),
+  iconType: import_zod4.z.enum(["star", "heart", "thumbs", "number"]).optional()
 });
 var attributeConfigSchemas = {
   text: textConfigSchema,
@@ -2246,7 +2794,7 @@ function validateAttributeConfig(type, config) {
   }
   return {
     success: false,
-    errors: result.error.errors.map((err) => `${err.path.join(".")}: ${err.message}`)
+    errors: result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`)
   };
 }
 function parseAttributeConfig(type, config) {
@@ -2259,7 +2807,7 @@ function safeParseAttributeConfig(type, config) {
   return result.success ? result.data : void 0;
 }
 function createTextValidator(attr) {
-  let schema = import_zod3.z.string();
+  let schema = import_zod4.z.string();
   if (attr.minLength !== void 0) {
     schema = schema.min(
       attr.minLength,
@@ -2278,7 +2826,7 @@ function createTextValidator(attr) {
   return schema;
 }
 function createNumberValidator(attr) {
-  let schema = import_zod3.z.number();
+  let schema = import_zod4.z.number();
   if (attr.min !== void 0) {
     schema = schema.min(attr.min, `${attr.label} must be at least ${attr.min}`);
   }
@@ -2291,81 +2839,75 @@ function createNumberValidator(attr) {
   return schema;
 }
 function createCheckboxValidator(_attr) {
-  return import_zod3.z.boolean();
+  return import_zod4.z.boolean();
 }
 function createDateValidator(attr) {
-  return import_zod3.z.string().datetime({ message: `${attr.label} must be a valid ISO date` });
+  return import_zod4.z.string().datetime({ message: `${attr.label} must be a valid ISO date` });
 }
 function createPhoneValidator(_attr) {
-  return import_zod3.z.object({
-    countryCode: import_zod3.z.string().length(3),
-    phoneNumber: import_zod3.z.string().min(1)
+  return import_zod4.z.object({
+    countryCode: import_zod4.z.string().length(3),
+    phoneNumber: import_zod4.z.string().min(1)
   });
 }
 function createCurrencyValidator(_attr) {
-  return import_zod3.z.object({
-    code: import_zod3.z.string().length(3),
-    value: import_zod3.z.number().min(0)
+  return import_zod4.z.object({
+    code: import_zod4.z.string().length(3),
+    value: import_zod4.z.number().min(0)
   });
 }
 function createStatusValidator(attr) {
   const validValues = attr.options.map((opt) => opt.value);
-  return import_zod3.z.enum(validValues, {
-    errorMap: () => ({
-      message: `${attr.label} must be one of: ${validValues.join(", ")}`
-    })
+  return import_zod4.z.enum(validValues, {
+    error: `${attr.label} must be one of: ${validValues.join(", ")}`
   });
 }
 function createSelectValidator(attr) {
   const validValues = attr.options.map((opt) => opt.value);
-  return import_zod3.z.enum(validValues, {
-    errorMap: () => ({
-      message: `${attr.label} must be one of: ${validValues.join(", ")}`
-    })
+  return import_zod4.z.enum(validValues, {
+    error: `${attr.label} must be one of: ${validValues.join(", ")}`
   });
 }
 function createMultiselectValidator(attr) {
   const validValues = attr.options.map((opt) => opt.value);
-  return import_zod3.z.array(
-    import_zod3.z.enum(validValues, {
-      errorMap: () => ({
-        message: `Each value must be one of: ${validValues.join(", ")}`
-      })
+  return import_zod4.z.array(
+    import_zod4.z.enum(validValues, {
+      error: `Each value must be one of: ${validValues.join(", ")}`
     })
   );
 }
 function createLocationValidator(_attr) {
-  return import_zod3.z.object({
-    address: import_zod3.z.string().optional(),
-    address2: import_zod3.z.string().optional(),
-    city: import_zod3.z.string().optional(),
-    state: import_zod3.z.string().optional(),
-    postalCode: import_zod3.z.string().optional(),
-    country: import_zod3.z.string().length(3).optional(),
-    latitude: import_zod3.z.number().optional(),
-    longitude: import_zod3.z.number().optional()
+  return import_zod4.z.object({
+    address: import_zod4.z.string().optional(),
+    address2: import_zod4.z.string().optional(),
+    city: import_zod4.z.string().optional(),
+    state: import_zod4.z.string().optional(),
+    postalCode: import_zod4.z.string().optional(),
+    country: import_zod4.z.string().length(3).optional(),
+    latitude: import_zod4.z.number().optional(),
+    longitude: import_zod4.z.number().optional()
   });
 }
 function createTimestampValidator(_attr) {
-  return import_zod3.z.number().int().positive();
+  return import_zod4.z.number().int().positive();
 }
 function createFileValidator(_attr) {
-  return import_zod3.z.string().uuid();
+  return import_zod4.z.string().uuid();
 }
 function createUserValidator(_attr) {
-  return import_zod3.z.string().uuid();
+  return import_zod4.z.string().uuid();
 }
 function createSingleRelationValidator(attr) {
-  const uuidSchema = import_zod3.z.string().uuid({
+  const uuidSchema = import_zod4.z.string().uuid({
     message: `${attr.label} must be a valid record ID`
   });
-  return import_zod3.z.union([uuidSchema, import_zod3.z.null()]);
+  return import_zod4.z.union([uuidSchema, import_zod4.z.null()]);
 }
 function createMultiRelationValidator(attr) {
-  const uuidSchema = import_zod3.z.string().uuid({
+  const uuidSchema = import_zod4.z.string().uuid({
     message: `Each ${attr.label} item must be a valid record ID`
   });
-  let arraySchema = import_zod3.z.array(uuidSchema);
+  let arraySchema = import_zod4.z.array(uuidSchema);
   if (attr.minItems !== void 0) {
     arraySchema = arraySchema.min(
       attr.minItems,
@@ -2387,7 +2929,7 @@ function createRelationValidator(attr) {
   return createSingleRelationValidator(attr);
 }
 function createRatingValidator(attr) {
-  let schema = import_zod3.z.number().int().min(0);
+  let schema = import_zod4.z.number().int().min(0);
   if (attr.max !== void 0) {
     schema = schema.max(attr.max, `${attr.label} must be at most ${attr.max}`);
   }
@@ -2426,7 +2968,7 @@ function createAttributeValidator(attr) {
     case "rating":
       return createRatingValidator(attr);
     default:
-      return import_zod3.z.unknown();
+      return import_zod4.z.unknown();
   }
 }
 function createObjectValidator(objectDef) {
@@ -2438,7 +2980,7 @@ function createObjectValidator(objectDef) {
     }
     shape[attr.name] = validator;
   }
-  return import_zod3.z.object(shape);
+  return import_zod4.z.object(shape);
 }
 function validateAttribute(attr, value) {
   const validator = createAttributeValidator(attr);
@@ -2454,7 +2996,7 @@ function validateAttribute(attr, value) {
   }
   return {
     success: false,
-    errors: result.error.errors.map((err) => ({
+    errors: result.error.issues.map((err) => ({
       path: [attr.name, ...err.path.map(String)],
       message: err.message
     }))
@@ -2471,7 +3013,7 @@ function validateObject(objectDef, data) {
   }
   return {
     success: false,
-    errors: result.error.errors.map((err) => ({
+    errors: result.error.issues.map((err) => ({
       path: err.path.map(String),
       message: err.message
     }))
@@ -2492,7 +3034,7 @@ function createDraftValidator(objectDef) {
     const validator = createAttributeValidator(attr).optional();
     shape[attr.name] = validator;
   }
-  return import_zod3.z.object(shape);
+  return import_zod4.z.object(shape);
 }
 function validateDraft(objectDef, data) {
   const validator = createDraftValidator(objectDef);
@@ -2505,7 +3047,7 @@ function validateDraft(objectDef, data) {
   }
   return {
     success: false,
-    errors: result.error.errors.map((err) => ({
+    errors: result.error.issues.map((err) => ({
       path: err.path.map(String),
       message: err.message
     }))
@@ -2607,6 +3149,24 @@ function extractAttributeNames(template) {
   }
   return names;
 }
+function hasOptions(attr) {
+  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+}
+function enrichValuesWithSelectLabels(values, attributes) {
+  const enriched = { ...values };
+  for (const attr of attributes) {
+    const value = values[attr.name];
+    if (value == null) continue;
+    const isSelectLike = attr.type === "select" || attr.type === "status" || attr.type === "multiselect";
+    if (!(isSelectLike && hasOptions(attr))) continue;
+    if (attr.type === "multiselect" && Array.isArray(value) && value.length === 0) continue;
+    const formatted = formatAttributeValue(value, attr);
+    if (formatted && formatted !== EMPTY_VALUE_PLACEHOLDER) {
+      enriched[attr.name] = formatted;
+    }
+  }
+  return enriched;
+}
 
 // src/runtime/mock-adapter.ts
 function createMockObjectsRepository(stores) {
@@ -3083,14 +3643,31 @@ function createMockObjectRecordsRepository(stores) {
           (options.offset ?? 0) + options.limit
         );
       }
+      const attributesByObjectId = /* @__PURE__ */ new Map();
+      for (const attr of stores.attributes.values()) {
+        if (!attributesByObjectId.has(attr.objectId)) {
+          attributesByObjectId.set(attr.objectId, []);
+        }
+        attributesByObjectId.get(attr.objectId)?.push(attr);
+      }
       const results = matchingRecords.map((r) => {
         const obj = objectsMap.get(r.objectId);
         const labelExpression = obj?.labelExpression ?? "{{ name }}";
+        const dbAttrs = attributesByObjectId.get(r.objectId) ?? [];
+        const attrs = dbAttrs.map((a) => ({
+          ...a.config,
+          id: a.id,
+          name: a.name,
+          type: a.type,
+          label: a.config.label ?? a.name,
+          required: a.config.required ?? false
+        }));
+        const enrichedValues = enrichValuesWithSelectLabels(r.values, attrs);
         return {
           objectId: r.objectId,
           objectName: obj?.name ?? "unknown",
           objectLabel: obj?.label ?? "Unknown",
-          label: renderLabelExpression(labelExpression, r.values),
+          label: renderLabelExpression(labelExpression, enrichedValues),
           recordId: r.id,
           values: r.values,
           completionStatus: r.completionStatus,
@@ -3507,6 +4084,10 @@ var AuditService = class {
     this.options = options;
     this.buffer = [];
     this.flushTimer = null;
+    /** Prevents concurrent flush operations */
+    this.isFlushing = false;
+    /** Pending flush promise to allow waiting on concurrent flush */
+    this.flushPromise = null;
     if (options?.async && options.flushIntervalMs) {
       this.startFlushTimer();
     }
@@ -3659,14 +4240,23 @@ var AuditService = class {
   // ============================================================================
   /**
    * Flush buffered logs to the database
+   * Protected against concurrent flush calls
    */
   async flush() {
+    if (this.isFlushing && this.flushPromise) {
+      return this.flushPromise;
+    }
     if (this.buffer.length === 0 || !this.adapter.audit) {
       return;
     }
+    this.isFlushing = true;
     const entries = [...this.buffer];
     this.buffer = [];
-    await this.adapter.audit.createMany(entries);
+    this.flushPromise = this.adapter.audit.createMany(entries).finally(() => {
+      this.isFlushing = false;
+      this.flushPromise = null;
+    });
+    return this.flushPromise;
   }
   /**
    * Clean up resources (stop timer, flush remaining logs)
@@ -3688,6 +4278,12 @@ var AuditService = class {
     if (!this.adapter.audit) {
       return;
     }
+    if (entry.actorId && !entry.actorEmail && entry.actorType === "user") {
+      const profile = await this.adapter.userProfiles.findById(entry.actorId);
+      if (profile) {
+        entry.actorEmail = profile.email;
+      }
+    }
     if (this.options?.async) {
       this.buffer.push(entry);
       const batchSize = this.options.batchSize ?? 10;
@@ -3925,6 +4521,324 @@ var FileService = class {
   }
 };
 
+// src/runtime/services/flow.service.ts
+var FlowService = class {
+  constructor(adapter, systemFlows = []) {
+    this.adapter = adapter;
+    this.systemFlows = new Map(systemFlows.map((f) => [f.name, f]));
+  }
+  /**
+   * Get all flows for a tenant (system + custom)
+   */
+  async getAllFlows(tenantId) {
+    const systemFlowsList = Array.from(this.systemFlows.values());
+    if (!this.adapter.flows) {
+      return systemFlowsList;
+    }
+    const dbFlows = await this.adapter.flows.findAllForTenant(tenantId);
+    const customFlows = dbFlows.filter((f) => !f.system).map(this.convertDBFlowToDefinition);
+    return [...systemFlowsList, ...customFlows];
+  }
+  /**
+   * Get published flows only
+   */
+  async getPublishedFlows(tenantId) {
+    const allFlows = await this.getAllFlows(tenantId);
+    return allFlows.filter((f) => f.status === "published");
+  }
+  /**
+   * Get a specific flow by name
+   */
+  async getFlow(name, tenantId) {
+    const systemFlow = this.systemFlows.get(name);
+    if (systemFlow) {
+      return systemFlow;
+    }
+    if (!this.adapter.flows) {
+      return null;
+    }
+    const dbFlow = await this.adapter.flows.findByName(tenantId, name);
+    if (dbFlow) {
+      return this.convertDBFlowToDefinition(dbFlow);
+    }
+    return null;
+  }
+  /**
+   * Get a flow by ID
+   */
+  async getFlowById(flowId) {
+    if (!this.adapter.flows) {
+      return null;
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (dbFlow) {
+      return this.convertDBFlowToDefinition(dbFlow);
+    }
+    return null;
+  }
+  /**
+   * Create a new custom flow (as draft)
+   */
+  async createFlow(input, tenantId) {
+    if (!this.adapter.flows) {
+      throw new SchemaError(
+        "Flows feature is not enabled. Database adapter does not support flows.",
+        SchemaErrorCode.UNKNOWN,
+        { feature: "flows" }
+      );
+    }
+    this.validateFlowName(input.name);
+    const existing = await this.adapter.flows.findByName(tenantId, input.name);
+    if (existing) {
+      throw new SchemaError(
+        `Flow "${input.name}" already exists`,
+        SchemaErrorCode.DUPLICATE_OBJECT,
+        { flowName: input.name }
+      );
+    }
+    if (this.systemFlows.has(input.name)) {
+      throw new SchemaError(
+        `Cannot create flow "${input.name}": a system flow with this name already exists`,
+        SchemaErrorCode.DUPLICATE_OBJECT,
+        { flowName: input.name, system: true }
+      );
+    }
+    this.validateFlowStructure(input);
+    const dbFlow = await this.adapter.flows.create({
+      tenantId,
+      name: input.name,
+      label: input.label,
+      description: input.description,
+      icon: input.icon,
+      status: "draft",
+      version: 1,
+      slots: input.slots,
+      pages: input.pages,
+      relations: input.relations,
+      system: false,
+      metadata: input.metadata
+    });
+    return this.convertDBFlowToDefinition(dbFlow);
+  }
+  /**
+   * Update a custom flow
+   */
+  async updateFlow(flowId, input) {
+    if (!this.adapter.flows) {
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new NotFoundError("Flow", flowId);
+    }
+    if (dbFlow.system) {
+      throw new ProtectedResourceError("object", dbFlow.name, "modify");
+    }
+    if (input.slots || input.pages || input.relations) {
+      this.validateFlowStructure({
+        name: dbFlow.name,
+        label: input.label ?? dbFlow.label,
+        slots: input.slots ?? dbFlow.slots,
+        pages: input.pages ?? dbFlow.pages,
+        relations: input.relations ?? dbFlow.relations
+      });
+    }
+    const updated = await this.adapter.flows.update(flowId, {
+      label: input.label,
+      description: input.description,
+      icon: input.icon,
+      slots: input.slots,
+      pages: input.pages,
+      relations: input.relations,
+      metadata: input.metadata
+    });
+    return this.convertDBFlowToDefinition(updated);
+  }
+  /**
+   * Publish a flow
+   */
+  async publishFlow(flowId) {
+    if (!this.adapter.flows) {
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new NotFoundError("Flow", flowId);
+    }
+    if (dbFlow.system) {
+      throw new ProtectedResourceError("object", dbFlow.name, "modify");
+    }
+    if (dbFlow.status === "published") {
+      return this.convertDBFlowToDefinition(dbFlow);
+    }
+    this.validateFlowStructure({
+      name: dbFlow.name,
+      label: dbFlow.label,
+      slots: dbFlow.slots,
+      pages: dbFlow.pages,
+      relations: dbFlow.relations
+    });
+    const updated = await this.adapter.flows.update(flowId, {
+      status: "published",
+      version: dbFlow.version + 1
+    });
+    return this.convertDBFlowToDefinition(updated);
+  }
+  /**
+   * Archive a flow
+   */
+  async archiveFlow(flowId) {
+    if (!this.adapter.flows) {
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new NotFoundError("Flow", flowId);
+    }
+    if (dbFlow.system) {
+      throw new ProtectedResourceError("object", dbFlow.name, "modify");
+    }
+    const updated = await this.adapter.flows.update(flowId, {
+      status: "archived"
+    });
+    return this.convertDBFlowToDefinition(updated);
+  }
+  /**
+   * Delete a custom flow
+   */
+  async deleteFlow(flowId) {
+    if (!this.adapter.flows) {
+      throw new SchemaError("Flows feature is not enabled.", SchemaErrorCode.UNKNOWN, {
+        feature: "flows"
+      });
+    }
+    const dbFlow = await this.adapter.flows.findById(flowId);
+    if (!dbFlow) {
+      throw new NotFoundError("Flow", flowId);
+    }
+    if (dbFlow.system) {
+      throw new ProtectedResourceError("object", dbFlow.name, "delete");
+    }
+    await this.adapter.flows.delete(flowId);
+  }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
+  /**
+   * Validate flow name format (kebab-case)
+   */
+  validateFlowName(name) {
+    if (!name || name.length === 0) {
+      throw new ValidationError("Flow name cannot be empty", [
+        { path: ["name"], message: "Flow name cannot be empty" }
+      ]);
+    }
+    if (name.length > 63) {
+      throw new ValidationError("Flow name is too long", [
+        { path: ["name"], message: "Flow name is too long (max 63 characters)" }
+      ]);
+    }
+    const kebabCaseRegex = /^[a-z][a-z0-9-]*$/;
+    if (!kebabCaseRegex.test(name)) {
+      throw new ValidationError("Invalid flow name format", [
+        {
+          path: ["name"],
+          message: "Flow name must be in kebab-case (e.g., 'couple-creation', 'new-contact')"
+        }
+      ]);
+    }
+  }
+  /**
+   * Validate flow structure (slots, pages, relations)
+   */
+  validateFlowStructure(input) {
+    if (!input.slots || input.slots.length === 0) {
+      throw new ValidationError("Flow must have at least one slot", [
+        { path: ["slots"], message: "Flow must have at least one slot" }
+      ]);
+    }
+    if (!input.pages || input.pages.length === 0) {
+      throw new ValidationError("Flow must have at least one page", [
+        { path: ["pages"], message: "Flow must have at least one page" }
+      ]);
+    }
+    const slotIds = new Set(input.slots.map((s) => s.id));
+    if (slotIds.size !== input.slots.length) {
+      throw new ValidationError("Duplicate slot IDs detected", [
+        { path: ["slots"], message: "Duplicate slot IDs detected" }
+      ]);
+    }
+    for (const page of input.pages) {
+      for (const row of page.rows) {
+        for (const field of row.fields) {
+          if (!slotIds.has(field.slotId)) {
+            throw new ValidationError("Field references unknown slot", [
+              {
+                path: ["pages", page.id, "rows", row.id, "fields", field.id],
+                message: `Field "${field.id}" references unknown slot "${field.slotId}"`
+              }
+            ]);
+          }
+        }
+      }
+    }
+    for (const relation2 of input.relations) {
+      if (!slotIds.has(relation2.sourceSlotId)) {
+        throw new ValidationError("Relation references unknown source slot", [
+          {
+            path: ["relations", relation2.id, "sourceSlotId"],
+            message: `Relation references unknown source slot "${relation2.sourceSlotId}"`
+          }
+        ]);
+      }
+      if (!slotIds.has(relation2.targetSlotId)) {
+        throw new ValidationError("Relation references unknown target slot", [
+          {
+            path: ["relations", relation2.id, "targetSlotId"],
+            message: `Relation references unknown target slot "${relation2.targetSlotId}"`
+          }
+        ]);
+      }
+      if (relation2.sourceSlotId === relation2.targetSlotId) {
+        throw new ValidationError("Relation cannot link a slot to itself", [
+          {
+            path: ["relations", relation2.id],
+            message: `Relation cannot link a slot to itself: "${relation2.sourceSlotId}"`
+          }
+        ]);
+      }
+    }
+  }
+  /**
+   * Convert database flow to FlowDefinition
+   */
+  convertDBFlowToDefinition(dbFlow) {
+    return {
+      id: dbFlow.id,
+      name: dbFlow.name,
+      label: dbFlow.label,
+      description: dbFlow.description,
+      icon: dbFlow.icon,
+      status: dbFlow.status,
+      version: dbFlow.version,
+      slots: dbFlow.slots,
+      pages: dbFlow.pages,
+      relations: dbFlow.relations,
+      system: dbFlow.system,
+      tenantId: dbFlow.tenantId,
+      metadata: dbFlow.metadata,
+      createdAt: dbFlow.createdAt,
+      updatedAt: dbFlow.updatedAt
+    };
+  }
+};
+
 // src/runtime/services/geocoding.service.ts
 var GeocodingService = class {
   constructor(adapter) {
@@ -4390,14 +5304,15 @@ var ObjectSchemaService = class {
         });
       }
     }
+    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
+    const attributes = dbAttributes.map((attr) => this.convertDBAttributeToAttribute(attr));
     if (updates.labelExpression !== void 0 && updates.labelExpression !== oldValues.labelExpression) {
       const newExpression = updates.labelExpression;
-      await this.adapter.objectRecords.batchRefreshLabels(
-        objectId,
-        (values) => renderLabelExpression(newExpression, values)
-      );
+      await this.adapter.objectRecords.batchRefreshLabels(objectId, (values) => {
+        const enrichedValues = enrichValuesWithSelectLabels(values, attributes);
+        return renderLabelExpression(newExpression, enrichedValues);
+      });
     }
-    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
     return this.convertDBObjectToDefinition(updatedDbObject, dbAttributes);
   }
   /**
@@ -4716,6 +5631,8 @@ var PermissionService = class {
     this.adapter = adapter;
     this.tenantId = tenantId;
     this.cache = /* @__PURE__ */ new Map();
+    /** Track pending permission fetches to prevent duplicate concurrent requests */
+    this.pendingFetches = /* @__PURE__ */ new Map();
     if (!adapter.permissions) {
       throw new Error(
         "PermissionService requires a DatabaseAdapter with permissions repository. Make sure your adapter implements the permissions property."
@@ -4864,6 +5781,23 @@ var PermissionService = class {
     if (cached && cached.expiresAt > Date.now()) {
       return cached.permissions;
     }
+    const pendingFetch = this.pendingFetches.get(cacheKey);
+    if (pendingFetch) {
+      return pendingFetch;
+    }
+    const fetchPromise = this.fetchAndCachePermissions(userProfileId, cacheKey);
+    this.pendingFetches.set(cacheKey, fetchPromise);
+    try {
+      return await fetchPromise;
+    } finally {
+      this.pendingFetches.delete(cacheKey);
+    }
+  }
+  /**
+   * Fetch permissions from database and cache the result
+   * @internal
+   */
+  async fetchAndCachePermissions(userProfileId, cacheKey) {
     const permissions = await this.permissionsRepo.getEffectivePermissions(
       userProfileId,
       this.tenantId
@@ -5246,8 +6180,11 @@ var RelationService = class {
   async validateRelationsOrThrow(schema, data) {
     const result = await this.validateRelations(schema, data);
     if (!result.valid) {
-      const messages = result.errors.map((e) => `${e.attribute}: ${e.message}`).join("; ");
-      throw new Error(`Relation validation failed: ${messages}`);
+      const errors = result.errors.map((e) => ({
+        path: [e.attribute],
+        message: e.message
+      }));
+      throw new ValidationError("Relation validation failed", errors);
     }
   }
   // ============================================================================
@@ -5295,7 +6232,8 @@ var RelationService = class {
       totalCount += result.total;
       for (const record of result.records) {
         const template = target.displayTemplate || objectSchema.labelExpression;
-        const label = renderLabelExpression(template, record.values);
+        const enrichedValues = enrichValuesWithSelectLabels(record.values, objectSchema.attributes);
+        const label = renderLabelExpression(template, enrichedValues);
         allOptions.push({
           id: record.id,
           objectId: objectSchema.id,
@@ -5359,7 +6297,8 @@ var RelationService = class {
         }
       }
       for (const record of objectRecords) {
-        const label = renderLabelExpression(template, record.values);
+        const enrichedValues = enrichValuesWithSelectLabels(record.values, objectSchema.attributes);
+        const label = renderLabelExpression(template, enrichedValues);
         resolved.push({
           id: record.id,
           objectId: record.objectId,
@@ -5380,10 +6319,14 @@ var RelationService = class {
     if (!attribute || attribute.type !== "relation") {
       return null;
     }
-    return {
+    const merged = {
       ...attribute.config,
       ...attribute
     };
+    if (!("targets" in merged && Array.isArray(merged.targets) && "cardinality" in merged)) {
+      return null;
+    }
+    return merged;
   }
 };
 
@@ -5396,7 +6339,7 @@ var RecordService = class {
     this.relationService = new RelationService(adapter, registry);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
     this.permissionService = options?.permissionService;
-    this.auditService = options?.auditService;
+    this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter, tenantId) : void 0);
     this.userId = options?.userId;
     this.userEmail = options?.userEmail;
   }
@@ -5463,21 +6406,23 @@ var RecordService = class {
   /**
    * Compute display label from schema expression
    * Automatically resolves relation attribute values to their labels
+   * and select/multiselect values to their option labels
    * @internal
    */
   async computeLabel(schema, values) {
     const attrNames = extractAttributeNames(schema.labelExpression);
+    let enrichedValues = enrichValuesWithSelectLabels(values, schema.attributes);
     const relationAttrs = schema.attributes.filter(
       (attr) => attr.type === "relation" && attrNames.includes(attr.name)
     );
     if (relationAttrs.length === 0) {
-      return renderLabelExpression(schema.labelExpression, values);
+      return renderLabelExpression(schema.labelExpression, enrichedValues);
     }
     const resolvedMap = await this.resolveRelationLabels(relationAttrs, values);
     if (resolvedMap.size === 0) {
-      return renderLabelExpression(schema.labelExpression, values);
+      return renderLabelExpression(schema.labelExpression, enrichedValues);
     }
-    const enrichedValues = { ...values };
+    enrichedValues = { ...enrichedValues };
     for (const attr of relationAttrs) {
       const val = values[attr.name];
       const ids = this.extractRelationIds(val);
@@ -5590,7 +6535,7 @@ var RecordService = class {
   async getRecordOrThrow(recordId) {
     const record = await this.getRecord(recordId);
     if (!record) {
-      throw new Error(`Record with id "${recordId}" not found`);
+      throw new RecordNotFoundError(recordId);
     }
     return record;
   }
@@ -5768,7 +6713,7 @@ var RecordService = class {
     await this.checkPermission(schema.name, "delete");
     if (options?.checkSystem) {
       if (schema.system) {
-        throw new Error(`Cannot delete record of system object "${schema.label}"`);
+        throw new ProtectedResourceError("object", schema.name, "delete");
       }
     }
     if (!options?.skipReferenceCheck) {
@@ -5817,7 +6762,11 @@ var RecordService = class {
   async restoreRecord(recordId, options) {
     const record = await this.getRecordOrThrow(recordId);
     if (!record.deletedAt) {
-      throw new Error(`Record "${recordId}" is not deleted`);
+      throw new SchemaError(
+        `Record "${recordId}" is not deleted`,
+        SchemaErrorCode.VALIDATION_FAILED,
+        { recordId, reason: "not_deleted" }
+      );
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
     await this.checkPermission(schema.name, "update");
@@ -6255,16 +7204,19 @@ var ViewService = class {
     this.validateViewName(input.name);
     const existing = await this.adapter.views.findByName(tenantId, input.objectName, input.name);
     if (existing) {
-      throw new Error(`View "${input.name}" already exists for object "${input.objectName}"`);
+      throw new SchemaError(
+        `View "${input.name}" already exists for object "${input.objectName}"`,
+        SchemaErrorCode.DUPLICATE_ATTRIBUTE,
+        { viewName: input.name, objectName: input.objectName }
+      );
     }
     if (this.nativeViews.has(input.objectName, input.name)) {
-      throw new Error(
-        `Cannot create view "${input.name}": a system view with this name already exists`
+      throw new SchemaError(
+        `Cannot create view "${input.name}": a system view with this name already exists`,
+        SchemaErrorCode.DUPLICATE_ATTRIBUTE,
+        { viewName: input.name, objectName: input.objectName, system: true }
       );
     }
-    if (!input.tabs || input.tabs.length === 0) {
-      throw new Error("View must have at least one tab");
-    }
     const dbView = await this.adapter.views.create({
       tenantId,
       objectName: input.objectName,
@@ -6272,7 +7224,7 @@ var ViewService = class {
       label: input.label,
       description: input.description,
       icon: input.icon,
-      tabs: input.tabs,
+      tabs: input.tabs ?? [],
       default: input.default ?? false,
       system: false,
       // Custom views are never system
@@ -6290,13 +7242,10 @@ var ViewService = class {
   async updateView(viewId, input) {
     const dbView = await this.adapter.views.findById(viewId);
     if (!dbView) {
-      throw new Error(`View with id "${viewId}" not found`);
+      throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new Error("Cannot modify system views. System views are protected.");
-    }
-    if (input.tabs && input.tabs.length === 0) {
-      throw new Error("View must have at least one tab");
+      throw new ProtectedResourceError("attribute", dbView.name, "modify");
     }
     const updated = await this.adapter.views.update(viewId, {
       label: input.label,
@@ -6316,10 +7265,10 @@ var ViewService = class {
   async deleteView(viewId) {
     const dbView = await this.adapter.views.findById(viewId);
     if (!dbView) {
-      throw new Error(`View with id "${viewId}" not found`);
+      throw new NotFoundError("View", viewId);
     }
     if (dbView.system) {
-      throw new Error("Cannot delete system views. System views are protected.");
+      throw new ProtectedResourceError("attribute", dbView.name, "delete");
     }
     await this.adapter.views.delete(viewId);
   }
@@ -6333,7 +7282,7 @@ var ViewService = class {
   async setDefaultView(viewId, tenantId) {
     const dbView = await this.adapter.views.findById(viewId);
     if (!dbView) {
-      throw new Error(`View with id "${viewId}" not found`);
+      throw new NotFoundError("View", viewId);
     }
     const currentViews = await this.adapter.views.findByObjectName(tenantId, dbView.objectName);
     for (const v of currentViews) {
@@ -6352,16 +7301,23 @@ var ViewService = class {
    */
   validateViewName(name) {
     if (!name || name.length === 0) {
-      throw new Error("View name cannot be empty");
+      throw new ValidationError("View name cannot be empty", [
+        { path: ["name"], message: "View name cannot be empty" }
+      ]);
     }
     if (name.length > 63) {
-      throw new Error("View name is too long (max 63 characters)");
+      throw new ValidationError("View name is too long", [
+        { path: ["name"], message: "View name is too long (max 63 characters)" }
+      ]);
     }
     const kebabCaseRegex = /^[a-z][a-z0-9-]*$/;
     if (!kebabCaseRegex.test(name)) {
-      throw new Error(
-        "Invalid view name format. Name must be in kebab-case (e.g., 'detail', 'list-view')"
-      );
+      throw new ValidationError("Invalid view name format", [
+        {
+          path: ["name"],
+          message: "View name must be in kebab-case (e.g., 'detail', 'list-view')"
+        }
+      ]);
     }
   }
   /**
@@ -6723,8 +7679,13 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   DEFAULT_ROLE_LABELS,
   DEFAULT_ROLE_PERMISSIONS,
   DuplicateError,
+  EMPTY_VALUE_PLACEHOLDER,
   FileNotFoundError,
   FileService,
+  FlowBuilder,
+  FlowPageBuilder,
+  FlowRowBuilder,
+  FlowService,
   ForbiddenError,
   GeocodingService,
   GlobalSearchService,
@@ -6789,9 +7750,12 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   currencyConfigSchema,
   date,
   dateConfigSchema,
+  enrichValuesWithSelectLabels,
   extractAttributeNames,
   file,
   fileConfigSchema,
+  flow,
+  formatAttributeValue,
   generateId,
   generatePrefixedId,
   getAttributeConfigSchema,
@@ -6799,9 +7763,12 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   getSyncPreview,
   getViewSyncPreview,
   group,
+  isActivityTab,
   isAdvancedFilterState,
   isCustomTab,
   isDefaultRole,
+  isFlowDefinition,
+  isFlowPublished,
   isForbiddenError,
   isFormTab,
   isLabelExpression,
@@ -6810,6 +7777,7 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
   isProtectedResourceError,
   isRecordComplete,
   isSchemaError,
+  isSystemFlow,
   isTableTab,
   isValidationError,
   location,