@stndrds/schema 0.1.0-alpha.55 → 0.1.0-alpha.56

package/dist/{chunk-4NLKDJWD.mjs → chunk-LOOGQL6M.mjs}

@@ -168,28 +168,28 @@ var WorkflowJwtService = class _WorkflowJwtService {
       if (message.includes("expired") || message.includes("exp")) {
         return {
           valid: false,
-          error: "Votre session a expir\xE9. Veuillez cliquer \xE0 nouveau sur le lien re\xE7u par email.",
+          error: "EXPIRED",
           errorCode: "EXPIRED"
         };
       }
       if (message.includes("signature") || message.includes("verification")) {
         return {
           valid: false,
-          error: "Lien invalide ou corrompu. Contactez l'exp\xE9diteur.",
+          error: "INVALID_SIGNATURE",
           errorCode: "INVALID_SIGNATURE"
         };
       }
       if (message.includes("malformed") || message.includes("invalid")) {
         return {
           valid: false,
-          error: "Format de token invalide.",
+          error: "MALFORMED",
           errorCode: "MALFORMED"
         };
       }
     }
     return {
       valid: false,
-      error: "Authentification \xE9chou\xE9e.",
+      error: "AUTH_FAILED",
       errorCode: "UNKNOWN"
     };
   }
@@ -249,6 +249,7 @@ var cacheKeys = {
   objectSchemaByName: (tenantId, name) => `schema:${tenantId}:name:${name}`,
   /** List of all object schemas */
   objectSchemaList: (tenantId) => `schema:${tenantId}:list`,
+  objectOwnerInfo: (tenantId, objectId) => `schema:${tenantId}:owner:${objectId}`,
   // -------------------------------------------------------------------------
   // Attributes - TTL: 1 hour (rarely change)
   // -------------------------------------------------------------------------
@@ -275,7 +276,15 @@ var cacheKeys = {
   // -------------------------------------------------------------------------
   // Rollups - TTL: 2 minutes (high volatility)
   // -------------------------------------------------------------------------
-  /** Computed rollup value for a record */
+  /**
+   * Computed rollup value for a record.
+   *
+   * NOTE: When used via `cachedBy("rollupValue", compositeId, ...)`, the compositeId
+   * is `${recordId}:${attrName}`. Since `cachedBy` calls `keyFn(tenantId, compositeId)`,
+   * the third parameter receives the composite string, producing the same key as
+   * calling `rollupValue(tenantId, recordId, attrName)` directly. This works because
+   * the colon separator in the composite matches the key format, but is intentional.
+   */
   rollupValue: (tenantId, recordId, attrName) => `rollup:${tenantId}:${recordId}:${attrName}`,
   // -------------------------------------------------------------------------
   // Records - TTL: 1 minute (high volatility)
@@ -419,6 +428,7 @@ var defaultTtl = {
   objectSchema: cacheTtl.schema,
   objectSchemaByName: cacheTtl.schema,
   objectSchemaList: cacheTtl.schemaList,
+  objectOwnerInfo: cacheTtl.schema,
   objectAttributes: cacheTtl.attributes,
   attributeById: cacheTtl.attributes,
   userProfileById: cacheTtl.userProfiles,
@@ -1344,6 +1354,9 @@ function getContextValue(context, path) {
     if (current === null || current === void 0) {
       return void 0;
     }
+    if (typeof current !== "object") {
+      return void 0;
+    }
     current = current[part];
   }
   return current;
@@ -1900,7 +1913,8 @@ var ConditionExecutor = class {
     };
     const nextNodeId = result ? node.onTrue : node.onFalse;
     if (!nextNodeId) {
-      throw new Error(
+      return error(
+        "MISSING_TARGET",
         `ConditionNode "${node.id}" has no ${result ? "onTrue" : "onFalse"} target defined`
       );
     }
@@ -1954,6 +1968,7 @@ var DocumentExecutor = class {
           filename: node.filename,
           metadata: {
             templateId: node.templateId,
+            templateVersion: node.templateVersion ?? 1,
             targetSlotIds: node.targetSlotIds ?? [],
             status: "pending"
           }
@@ -1976,6 +1991,36 @@ var DocumentExecutor = class {
     if (!node.next) {
       errors.push("DocumentNode must have a 'next' property");
     }
+    if (node.targetSlotIds && node.targetSlotIds.length > 0) {
+      for (const slotId of node.targetSlotIds) {
+        if (!slotId || typeof slotId !== "string" || slotId.trim() === "") {
+          errors.push("DocumentNode targetSlotIds must contain non-empty string values");
+          break;
+        }
+      }
+    }
+    return errors;
+  }
+  /**
+   * Validate that targetSlotIds reference existing slots in the workflow definition.
+   * This is a context-aware validation that requires the workflow's slot definitions.
+   *
+   * @param node - The document node to validate
+   * @param workflowSlots - All slots defined in the workflow
+   * @returns Array of validation error messages
+   */
+  validateSlotReferences(node, workflowSlots) {
+    const errors = [];
+    if (node.targetSlotIds && node.targetSlotIds.length > 0) {
+      const slotIdSet = new Set(workflowSlots.map((s) => s.id));
+      for (const slotId of node.targetSlotIds) {
+        if (!slotIdSet.has(slotId)) {
+          errors.push(
+            `DocumentNode "${node.id}" references unknown slot "${slotId}" in targetSlotIds`
+          );
+        }
+      }
+    }
     return errors;
   }
 };
@@ -2029,8 +2074,20 @@ var FormExecutor = class {
         ...slotInput
       };
     }
+    if (context.objectDefinitions && context.objectDefinitions.length > 0) {
+      const typedInput = input;
+      const validationErrors = this.validateRequiredFields(
+        node,
+        typedInput,
+        context.definition.slots,
+        context.objectDefinitions
+      );
+      if (validationErrors.length > 0) {
+        return error("VALIDATION_FAILED", validationErrors.join("; "));
+      }
+    }
     if (!node.next) {
-      throw new Error(`FormNode "${node.id}" has no 'next' target defined`);
+      return error("MISSING_NEXT", `FormNode "${node.id}" has no 'next' target defined`);
     }
     return success(node.next, contextUpdates);
   }
@@ -2196,7 +2253,7 @@ function createFormulaParser() {
   parser.functions.LENGTH = (value) => String(value ?? "").length;
   parser.functions.LEFT = (value, count) => String(value ?? "").slice(0, count);
   parser.functions.RIGHT = (value, count) => String(value ?? "").slice(-count);
-  parser.functions.REPLACE = (value, search, replacement) => String(value ?? "").replace(new RegExp(search, "g"), replacement);
+  parser.functions.REPLACE = (value, search, replacement) => String(value ?? "").split(String(search)).join(replacement);
   parser.functions.CONTAINS = (value, search) => String(value ?? "").toLowerCase().includes(String(search).toLowerCase());
   parser.functions.ROUND = (value, decimals = 0) => {
     if (typeof value !== "number" || Number.isNaN(value)) return null;
@@ -2562,359 +2619,418 @@ var NoopHookRegistry = class {
   }
 };
 
-// src/format.ts
-import { getCountryByIso3 } from "@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;
-  if (attribute.unit === "integer") {
-    return value.toLocaleString(void 0, {
-      minimumFractionDigits: 0,
-      maximumFractionDigits: 0
-    });
-  }
-  if (attribute.unit === "percentage") {
-    return (value / 100).toLocaleString(void 0, {
-      style: "percent",
-      minimumFractionDigits: decimals,
-      maximumFractionDigits: 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 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 = getCountryByIso3(phone2.countryCode);
-    const dial = country?.phoneCode ?? "";
-    return `${dial} ${phone2.phoneNumber}`.trim();
+// src/runtime/mock/mock-ai.ts
+function requireUserId() {
+  const userId = getUserId();
+  if (!userId) {
+    throw new Error("User context required for AI operations");
   }
-  return phone2.phoneNumber;
+  return userId;
 }
-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}`);
+function createMockAIConversationsRepository(stores) {
+  return {
+    findById(id) {
+      const conversation = stores.aiConversations.get(id);
+      if (!conversation || conversation.deletedAt) return Promise.resolve(null);
+      const tenantId = getTenantId();
+      if (conversation.tenantId !== tenantId) return Promise.resolve(null);
+      return Promise.resolve(conversation);
+    },
+    list(options) {
+      const tenantId = getTenantId();
+      const userId = requireUserId();
+      let results = Array.from(stores.aiConversations.values()).filter((c) => {
+        if (c.tenantId !== tenantId || c.userId !== userId) return false;
+        if (!options?.includeDeleted && c.deletedAt) return false;
+        return true;
+      });
+      results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
+      const total = results.length;
+      if (options?.limit) {
+        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
       }
-      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}`;
+      return Promise.resolve({ conversations: results, total });
+    },
+    create(data) {
+      const tenantId = getTenantId();
+      const userId = requireUserId();
+      const now = /* @__PURE__ */ new Date();
+      const conversation = {
+        id: generateId(),
+        tenantId,
+        userId,
+        title: data.title ?? null,
+        messageCount: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        createdAt: now,
+        updatedAt: now,
+        deletedAt: null
+      };
+      stores.aiConversations.set(conversation.id, conversation);
+      return Promise.resolve(conversation);
+    },
+    updateTitle(id, title) {
+      const conversation = stores.aiConversations.get(id);
+      if (!conversation || conversation.deletedAt) return Promise.resolve(null);
+      const tenantId = getTenantId();
+      if (conversation.tenantId !== tenantId) return Promise.resolve(null);
+      conversation.title = title;
+      conversation.updatedAt = /* @__PURE__ */ new Date();
+      stores.aiConversations.set(id, conversation);
+      return Promise.resolve(conversation);
+    },
+    delete(id) {
+      const conversation = stores.aiConversations.get(id);
+      if (!conversation) return Promise.resolve(false);
+      const tenantId = getTenantId();
+      if (conversation.tenantId !== tenantId) return Promise.resolve(false);
+      conversation.deletedAt = /* @__PURE__ */ new Date();
+      stores.aiConversations.set(id, conversation);
+      return Promise.resolve(true);
+    },
+    addMessage(input) {
+      const now = /* @__PURE__ */ new Date();
+      const message = {
+        id: generateId(),
+        conversationId: input.conversationId,
+        role: input.role,
+        content: input.content,
+        thinkingLevel: input.thinkingLevel ?? null,
+        thinkingSummary: input.thinkingSummary ?? null,
+        toolCalls: input.toolCalls ?? null,
+        inputTokens: input.inputTokens ?? null,
+        outputTokens: input.outputTokens ?? null,
+        cost: input.cost ?? null,
+        provider: input.provider ?? null,
+        model: input.model ?? null,
+        attachmentIds: input.attachmentIds ?? null,
+        createdAt: now
+      };
+      stores.aiMessages.set(message.id, message);
+      const conversation = stores.aiConversations.get(input.conversationId);
+      if (conversation) {
+        conversation.messageCount++;
+        conversation.totalTokens += (input.inputTokens ?? 0) + (input.outputTokens ?? 0);
+        conversation.totalCost += input.cost ?? 0;
+        conversation.updatedAt = now;
+        stores.aiConversations.set(input.conversationId, conversation);
+      }
+      return Promise.resolve(message);
+    },
+    listMessages(conversationId, options) {
+      let results = Array.from(stores.aiMessages.values()).filter((m) => m.conversationId === conversationId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
+      const total = results.length;
+      if (options?.limit) {
+        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
+      }
+      return Promise.resolve({ messages: results, total });
+    },
+    getRecentMessages(conversationId, count = 20) {
+      const results = Array.from(stores.aiMessages.values()).filter((m) => m.conversationId === conversationId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).slice(-count);
+      return Promise.resolve(results);
+    }
+  };
 }
-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 "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/runtime/template.ts
-var simplePipes = {
-  /** Convert to uppercase */
-  UPPER: (v) => String(v).toUpperCase(),
-  /** Convert to lowercase */
-  LOWER: (v) => String(v).toLowerCase(),
-  /** Capitalize first letter of each word */
-  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
-  /** Trim whitespace from both ends */
-  trim: (v) => String(v).trim()
-};
-var pipesWithArgs = {
-  /** Add prefix only if value is non-empty */
-  prefix: (v, pre = "") => v ? `${pre}${v}` : "",
-  /** Add suffix only if value is non-empty */
-  suffix: (v, suf = "") => v ? `${v}${suf}` : "",
-  /** Wrap value with prefix and suffix only if non-empty */
-  wrap: (v, pre = "", suf = "") => v ? `${pre}${v}${suf}` : "",
-  /** Show default value if empty */
-  default: (v, def = "") => v || def
-};
-function getValue(obj, path) {
-  return path.split(".").reduce((acc, key) => {
-    if (acc == null || typeof acc !== "object") return void 0;
-    return acc[key];
-  }, obj);
-}
-var DEFAULT_LABEL_FALLBACK = "(Untitled)";
-function parsePipeExpression(pipeExpr) {
-  const match = pipeExpr.match(/^(\w+)(?::(.*))?$/);
-  if (!match) return { name: pipeExpr, args: [] };
-  const name = match[1];
-  const argsStr = match[2];
-  if (!argsStr) return { name, args: [] };
-  const args = [];
-  const argRegex = /["']([^"']*?)["']/g;
-  let argMatch;
-  while ((argMatch = argRegex.exec(argsStr)) !== null) {
-    args.push(argMatch[1]);
-  }
-  return { name, args };
-}
-function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
-  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
-    const parts = expr.split("|").map((s) => s.trim());
-    const path = parts[0];
-    let value = getValue(values, path);
-    const isEmpty3 = value == null || value === "";
-    if (isEmpty3 && parts.length === 1) return "";
-    for (let i = 1; i < parts.length; i++) {
-      const { name: pipeName, args } = parsePipeExpression(parts[i]);
-      const simpleFn = simplePipes[pipeName];
-      if (simpleFn) {
-        if (value != null && value !== "") {
-          value = simpleFn(String(value));
-        }
-      } else {
-        const argFn = pipesWithArgs[pipeName];
-        if (argFn) {
-          value = argFn(String(value ?? ""), ...args);
-        }
-      }
-    }
-    return String(value ?? "");
-  }).trim();
-  return result || fallback;
-}
-function isLabelExpression(value) {
-  return /\{\{\s*\S+.*\}\}/.test(value);
-}
-function extractAttributeNames(template) {
-  const names = [];
-  const regex = /\{\{\s*([^|}]+)/g;
-  let match;
-  while ((match = regex.exec(template)) !== null) {
-    const path = match[1].trim();
-    const rootName = path.split(".")[0];
-    if (rootName && !names.includes(rootName)) {
-      names.push(rootName);
-    }
-  }
-  return names;
-}
-function hasOptions(attr) {
-  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
-}
-var FORMATTABLE_TYPES = /* @__PURE__ */ new Set([
-  "currency",
-  "location",
-  "phone",
-  "date",
-  "rating",
-  "select",
-  "status",
-  "multiselect",
-  "number"
-]);
-function enrichValuesForDisplay(values, attributes) {
-  const enriched = { ...values };
-  for (const attr of attributes) {
-    const value = values[attr.name];
-    if (value == null) continue;
-    if (!FORMATTABLE_TYPES.has(attr.type)) 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;
-}
-var enrichValuesWithSelectLabels = enrichValuesForDisplay;
-function extractRelationIds(val) {
-  if (typeof val === "string") return [val];
-  if (Array.isArray(val) && typeof val[0] === "string") return [val[0]];
-  return [];
-}
-async function computeLabelWithRelations(template, values, attributes, resolveRelationIds) {
-  let enrichedValues = enrichValuesForDisplay(values, attributes);
-  const attrNames = extractAttributeNames(template);
-  const relationAttrs = attributes.filter(
-    (attr) => attr.type === "relation" && attrNames.includes(attr.name)
-  );
-  if (relationAttrs.length === 0) {
-    return renderLabelExpression(template, enrichedValues);
-  }
-  const allIds = [];
-  for (const attr of relationAttrs) {
-    const ids = extractRelationIds(values[attr.name]);
-    allIds.push(...ids);
-  }
-  if (allIds.length === 0) {
-    return renderLabelExpression(template, enrichedValues);
-  }
-  const resolvedMap = await resolveRelationIds(allIds);
-  enrichedValues = { ...enrichedValues };
-  for (const attr of relationAttrs) {
-    const ids = extractRelationIds(values[attr.name]);
-    if (ids.length > 0 && resolvedMap.has(ids[0])) {
-      enrichedValues[attr.name] = resolvedMap.get(ids[0]);
-    }
-  }
-  return renderLabelExpression(template, enrichedValues);
-}
-
-// src/runtime/mock-adapter.ts
-function createMockObjectsRepository(stores) {
+function createMockAIUserMemoryRepository(stores) {
+  const getKey = () => {
+    const tenantId = getTenantId();
+    const userId = requireUserId();
+    return `${tenantId}:${userId}`;
+  };
   return {
-    findById(id) {
-      return Promise.resolve(stores.objects.get(id) ?? null);
+    get() {
+      const key = getKey();
+      return Promise.resolve(stores.aiUserMemory.get(key) ?? null);
     },
-    findByName(name) {
+    upsert(data) {
+      const key = getKey();
       const tenantId = getTenantId();
-      for (const obj of stores.objects.values()) {
-        if (obj.tenantId === tenantId && obj.name === name) {
-          return Promise.resolve(obj);
-        }
-      }
-      return Promise.resolve(null);
-    },
-    findSystemByName(name) {
-      for (const obj of stores.objects.values()) {
-        if (obj.system && obj.name === name) {
-          return Promise.resolve(obj);
-        }
-      }
-      return Promise.resolve(null);
+      const userId = requireUserId();
+      const now = /* @__PURE__ */ new Date();
+      const existing = stores.aiUserMemory.get(key);
+      const memory = {
+        id: existing?.id ?? generateId(),
+        tenantId,
+        userId,
+        preferences: data.preferences ?? existing?.preferences ?? {},
+        facts: data.facts ?? existing?.facts ?? [],
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      stores.aiUserMemory.set(key, memory);
+      return Promise.resolve(memory);
     },
-    create(data) {
+    addFact(fact) {
+      const key = getKey();
       const tenantId = getTenantId();
-      const obj = {
-        id: generateId(),
+      const userId = requireUserId();
+      const now = /* @__PURE__ */ new Date();
+      const existing = stores.aiUserMemory.get(key);
+      const memory = {
+        id: existing?.id ?? generateId(),
         tenantId,
-        name: data.name,
-        label: data.label,
-        pluralLabel: data.pluralLabel,
-        description: data.description,
-        icon: data.icon,
-        labelExpression: data.labelExpression,
-        system: data.system ?? false,
-        sharingMode: data.sharingMode ?? "private",
-        metadata: data.metadata,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
+        userId,
+        preferences: existing?.preferences ?? {},
+        facts: [...existing?.facts ?? [], fact],
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
       };
-      stores.objects.set(obj.id, obj);
-      return Promise.resolve(obj);
+      stores.aiUserMemory.set(key, memory);
+      return Promise.resolve(memory);
+    },
+    removeFact(fact) {
+      const key = getKey();
+      const tenantId = getTenantId();
+      const userId = requireUserId();
+      const now = /* @__PURE__ */ new Date();
+      const existing = stores.aiUserMemory.get(key);
+      const memory = {
+        id: existing?.id ?? generateId(),
+        tenantId,
+        userId,
+        preferences: existing?.preferences ?? {},
+        facts: (existing?.facts ?? []).filter((f) => f !== fact),
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      stores.aiUserMemory.set(key, memory);
+      return Promise.resolve(memory);
+    },
+    setPreference(prefKey, value) {
+      const memoryKey = getKey();
+      const tenantId = getTenantId();
+      const userId = requireUserId();
+      const now = /* @__PURE__ */ new Date();
+      const existing = stores.aiUserMemory.get(memoryKey);
+      const memory = {
+        id: existing?.id ?? generateId(),
+        tenantId,
+        userId,
+        preferences: { ...existing?.preferences ?? {}, [prefKey]: value },
+        facts: existing?.facts ?? [],
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      stores.aiUserMemory.set(memoryKey, memory);
+      return Promise.resolve(memory);
+    },
+    clear() {
+      const key = getKey();
+      stores.aiUserMemory.delete(key);
+      return Promise.resolve();
+    }
+  };
+}
+function createMockAIUsageMetricsRepository(stores) {
+  const getDateKey = (date2) => {
+    const tenantId = getTenantId();
+    const dateStr = date2.toISOString().split("T")[0];
+    return `${tenantId}:${dateStr}`;
+  };
+  return {
+    recordUsage(data) {
+      const tenantId = getTenantId();
+      const now = /* @__PURE__ */ new Date();
+      const key = getDateKey(now);
+      const existing = stores.aiUsageMetrics.get(key);
+      const providerBreakdown = existing?.providerBreakdown ?? {};
+      if (!providerBreakdown[data.provider]) {
+        providerBreakdown[data.provider] = { requests: 0, tokens: 0, cost: 0 };
+      }
+      providerBreakdown[data.provider].requests++;
+      providerBreakdown[data.provider].tokens += data.tokens;
+      providerBreakdown[data.provider].cost += data.cost;
+      const toolUsage = existing?.toolUsage ?? {};
+      if (data.toolName) {
+        toolUsage[data.toolName] = (toolUsage[data.toolName] ?? 0) + 1;
+      }
+      const metrics = {
+        id: existing?.id ?? generateId(),
+        tenantId,
+        date: new Date(now.toISOString().split("T")[0] ?? now.toISOString()),
+        requestCount: (existing?.requestCount ?? 0) + 1,
+        totalTokens: (existing?.totalTokens ?? 0) + data.tokens,
+        totalCost: (existing?.totalCost ?? 0) + data.cost,
+        providerBreakdown,
+        toolUsage
+      };
+      stores.aiUsageMetrics.set(key, metrics);
+      return Promise.resolve();
+    },
+    getByDateRange(startDate, endDate) {
+      const tenantId = getTenantId();
+      const results = Array.from(stores.aiUsageMetrics.values()).filter((m) => {
+        if (m.tenantId !== tenantId) return false;
+        return m.date >= startDate && m.date <= endDate;
+      });
+      results.sort((a, b) => a.date.getTime() - b.date.getTime());
+      return Promise.resolve(results);
+    },
+    getCurrentMonthUsage() {
+      const tenantId = getTenantId();
+      const now = /* @__PURE__ */ new Date();
+      const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
+      const monthMetrics = Array.from(stores.aiUsageMetrics.values()).filter((m) => {
+        if (m.tenantId !== tenantId) return false;
+        return m.date >= startOfMonth;
+      });
+      const aggregated = {
+        requestCount: 0,
+        totalTokens: 0,
+        totalCost: 0,
+        providerBreakdown: {}
+      };
+      for (const m of monthMetrics) {
+        aggregated.requestCount += m.requestCount;
+        aggregated.totalTokens += m.totalTokens;
+        aggregated.totalCost += m.totalCost;
+        for (const [provider, stats] of Object.entries(m.providerBreakdown)) {
+          if (!aggregated.providerBreakdown[provider]) {
+            aggregated.providerBreakdown[provider] = { requests: 0, tokens: 0, cost: 0 };
+          }
+          aggregated.providerBreakdown[provider].requests += stats.requests;
+          aggregated.providerBreakdown[provider].tokens += stats.tokens;
+          aggregated.providerBreakdown[provider].cost += stats.cost;
+        }
+      }
+      return Promise.resolve(aggregated);
+    }
+  };
+}
+
+// src/runtime/mock/mock-documents.ts
+function createMockFilesRepository(stores) {
+  return {
+    findById(id) {
+      const file2 = stores.files.get(id);
+      if (file2?.deletedAt) return Promise.resolve(null);
+      return Promise.resolve(file2 ?? null);
+    },
+    findByIds(ids) {
+      const files = ids.map((id) => stores.files.get(id)).filter((f) => f != null && !f.deletedAt);
+      return Promise.resolve(files);
+    },
+    create(data) {
+      const tenantId = getTenantId();
+      const file2 = {
+        id: generateId(),
+        tenantId,
+        name: data.name,
+        originalName: data.originalName,
+        mimeType: data.mimeType,
+        size: data.size,
+        storageProvider: data.storageProvider,
+        storagePath: data.storagePath,
+        storageBucket: data.storageBucket,
+        url: data.url,
+        uploadedBy: data.uploadedBy,
+        folderPath: data.folderPath,
+        tags: data.tags,
+        visibility: data.visibility ?? "private",
+        allowedUsers: data.allowedUsers,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.files.set(file2.id, file2);
+      return Promise.resolve(file2);
+    },
+    update(id, data) {
+      const existing = stores.files.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`File ${id} not found`));
+      }
+      const updated = {
+        ...existing,
+        ...data,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.files.set(id, updated);
+      return Promise.resolve(updated);
+    },
+    delete(id) {
+      const file2 = stores.files.get(id);
+      if (file2) {
+        file2.deletedAt = /* @__PURE__ */ new Date();
+        stores.files.set(id, file2);
+      }
+      return Promise.resolve();
+    },
+    hardDelete(id) {
+      stores.files.delete(id);
+      return Promise.resolve();
+    },
+    list(options) {
+      const tenantId = getTenantId();
+      let results = Array.from(stores.files.values()).filter(
+        (f) => f.tenantId === tenantId && !f.deletedAt
+      );
+      if (options?.mimeType) {
+        results = results.filter((f) => f.mimeType === options.mimeType);
+      }
+      if (options?.limit) {
+        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
+      }
+      return Promise.resolve(results);
+    },
+    findByFolder(folderPath) {
+      const tenantId = getTenantId();
+      const results = Array.from(stores.files.values()).filter(
+        (f) => f.tenantId === tenantId && f.folderPath === folderPath && !f.deletedAt
+      );
+      return Promise.resolve(results);
+    },
+    findByUploader(uploadedBy) {
+      const results = Array.from(stores.files.values()).filter(
+        (f) => f.uploadedBy === uploadedBy && !f.deletedAt
+      );
+      return Promise.resolve(results);
+    }
+  };
+}
+
+// src/runtime/mock/mock-object-definitions.ts
+function createMockObjectsRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.objects.get(id) ?? null);
+    },
+    findByName(name) {
+      const tenantId = getTenantId();
+      for (const obj of stores.objects.values()) {
+        if (obj.tenantId === tenantId && obj.name === name) {
+          return Promise.resolve(obj);
+        }
+      }
+      return Promise.resolve(null);
+    },
+    findSystemByName(name) {
+      for (const obj of stores.objects.values()) {
+        if (obj.system && obj.name === name) {
+          return Promise.resolve(obj);
+        }
+      }
+      return Promise.resolve(null);
+    },
+    create(data) {
+      const tenantId = getTenantId();
+      const obj = {
+        id: generateId(),
+        tenantId,
+        name: data.name,
+        label: data.label,
+        pluralLabel: data.pluralLabel,
+        description: data.description,
+        icon: data.icon,
+        labelExpression: data.labelExpression,
+        system: data.system ?? false,
+        sharingMode: data.sharingMode ?? "private",
+        metadata: data.metadata,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objects.set(obj.id, obj);
+      return Promise.resolve(obj);
     },
     update(id, data) {
       const existing = stores.objects.get(id);
@@ -3060,204 +3176,533 @@ function createMockAttributesRepository(stores) {
     }
   };
 }
-function createMockUserProfilesRepository(stores) {
-  return {
-    findById(id) {
-      return Promise.resolve(stores.userProfiles.get(id) ?? null);
-    },
-    findByIds(ids) {
-      const tenantId = getTenantId();
-      const results = [];
-      for (const id of ids) {
-        const profile = stores.userProfiles.get(id);
-        if (profile && profile.tenantId === tenantId) {
-          results.push(profile);
-        }
+
+// src/exceptions.ts
+var SchemaErrorCode = {
+  // Generic
+  UNKNOWN: "SCHEMA_UNKNOWN_ERROR",
+  // Not Found
+  OBJECT_NOT_FOUND: "SCHEMA_OBJECT_NOT_FOUND",
+  ATTRIBUTE_NOT_FOUND: "SCHEMA_ATTRIBUTE_NOT_FOUND",
+  RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND",
+  USER_PROFILE_NOT_FOUND: "SCHEMA_USER_PROFILE_NOT_FOUND",
+  FILE_NOT_FOUND: "SCHEMA_FILE_NOT_FOUND",
+  ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND",
+  // Validation
+  VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
+  INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME",
+  INVALID_OBJECT_NAME: "SCHEMA_INVALID_OBJECT_NAME",
+  // Protected Resources
+  PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT",
+  PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE",
+  PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW",
+  PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE",
+  // Permissions
+  FORBIDDEN: "SCHEMA_FORBIDDEN",
+  // Sync
+  SYNC_FAILED: "SCHEMA_SYNC_FAILED",
+  NOT_SYSTEM_OBJECT: "SCHEMA_NOT_SYSTEM_OBJECT",
+  // Duplicates
+  DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
+  DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE",
+  // Concurrency
+  CONFLICT: "SCHEMA_CONFLICT"
+};
+var SchemaError = class extends Error {
+  constructor(message, code = SchemaErrorCode.UNKNOWN, details) {
+    super(message);
+    this.name = "SchemaError";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+var NotFoundError = class extends SchemaError {
+  constructor(resourceType, resourceId, code = SchemaErrorCode.RECORD_NOT_FOUND) {
+    super(`${resourceType} with id "${resourceId}" not found`, code, {
+      resourceType,
+      resourceId
+    });
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var ObjectNotFoundError = class extends NotFoundError {
+  constructor(objectId) {
+    super("Object", objectId, SchemaErrorCode.OBJECT_NOT_FOUND);
+    this.name = "ObjectNotFoundError";
+  }
+};
+var AttributeNotFoundError = class extends NotFoundError {
+  constructor(attributeId) {
+    super("Attribute", attributeId, SchemaErrorCode.ATTRIBUTE_NOT_FOUND);
+    this.name = "AttributeNotFoundError";
+  }
+};
+var RecordNotFoundError = class extends NotFoundError {
+  constructor(recordId) {
+    super("Record", recordId, SchemaErrorCode.RECORD_NOT_FOUND);
+    this.name = "RecordNotFoundError";
+  }
+};
+var UserProfileNotFoundError = class extends NotFoundError {
+  constructor(identifier) {
+    super("UserProfile", identifier, SchemaErrorCode.USER_PROFILE_NOT_FOUND);
+    this.name = "UserProfileNotFoundError";
+  }
+};
+var FileNotFoundError = class extends NotFoundError {
+  constructor(fileId) {
+    super("File", fileId, SchemaErrorCode.FILE_NOT_FOUND);
+    this.name = "FileNotFoundError";
+  }
+};
+var ValidationError = class _ValidationError extends SchemaError {
+  constructor(message, errors) {
+    super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+  /**
+   * Create a validation error from Zod-style errors
+   */
+  static fromZodErrors(errors) {
+    const details = errors.map((err) => ({
+      path: err.path.map(String),
+      message: err.message
+    }));
+    const message = `Validation failed: ${details.map((d) => `${d.path.join(".")}: ${d.message}`).join(", ")}`;
+    return new _ValidationError(message, details);
+  }
+};
+var ProtectedResourceError = class extends SchemaError {
+  constructor(resourceType, resourceName, operation) {
+    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
+    super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
+      resourceType,
+      resourceName,
+      operation
+    });
+    this.name = "ProtectedResourceError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+    this.operation = operation;
+  }
+};
+var SyncError = class extends SchemaError {
+  constructor(objectName, message, cause) {
+    super(`Failed to sync object "${objectName}": ${message}`, SchemaErrorCode.SYNC_FAILED, {
+      objectName,
+      cause: cause?.message
+    });
+    this.name = "SyncError";
+    this.objectName = objectName;
+    this.cause = cause;
+  }
+};
+var NotSystemObjectError = class extends SchemaError {
+  constructor(objectName) {
+    super(
+      `Object "${objectName}" is not marked as system. Native objects must have system=true.`,
+      SchemaErrorCode.NOT_SYSTEM_OBJECT,
+      { objectName }
+    );
+    this.name = "NotSystemObjectError";
+    this.objectName = objectName;
+  }
+};
+var DuplicateError = class extends SchemaError {
+  constructor(resourceType, resourceName) {
+    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : SchemaErrorCode.DUPLICATE_ATTRIBUTE;
+    super(
+      `${resourceType === "object" ? "Object" : "Attribute"} "${resourceName}" already exists`,
+      code,
+      { resourceType, resourceName }
+    );
+    this.name = "DuplicateError";
+    this.resourceType = resourceType;
+    this.resourceName = resourceName;
+  }
+};
+function isSchemaError(error2) {
+  return error2 instanceof SchemaError;
+}
+function isNotFoundError(error2) {
+  return error2 instanceof NotFoundError;
+}
+function isValidationError(error2) {
+  return error2 instanceof ValidationError;
+}
+function isProtectedResourceError(error2) {
+  return error2 instanceof ProtectedResourceError;
+}
+var ForbiddenError = class extends SchemaError {
+  constructor(objectName, action, userId) {
+    super(`No ${action} permission on object "${objectName}"`, SchemaErrorCode.FORBIDDEN, {
+      objectName,
+      action,
+      userId
+    });
+    this.name = "ForbiddenError";
+    this.objectName = objectName;
+    this.action = action;
+    this.userId = userId;
+  }
+};
+var ProtectedRoleError = class extends SchemaError {
+  constructor(roleName, operation) {
+    super(`Cannot ${operation} system role "${roleName}"`, SchemaErrorCode.PROTECTED_ROLE, {
+      roleName,
+      operation
+    });
+    this.name = "ProtectedRoleError";
+    this.roleName = roleName;
+    this.operation = operation;
+  }
+};
+var RoleNotFoundError = class extends NotFoundError {
+  constructor(roleId) {
+    super("Role", roleId, SchemaErrorCode.ROLE_NOT_FOUND);
+    this.name = "RoleNotFoundError";
+  }
+};
+function isForbiddenError(error2) {
+  return error2 instanceof ForbiddenError;
+}
+var ConcurrentModificationError = class extends SchemaError {
+  constructor(recordId) {
+    super(
+      `Record ${recordId} was modified by another request. Please refresh and try again.`,
+      SchemaErrorCode.CONFLICT,
+      { recordId }
+    );
+  }
+};
+function isConcurrentModificationError(error2) {
+  return error2 instanceof ConcurrentModificationError;
+}
+
+// src/format.ts
+import { getCountryByIso3 } from "@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;
+  if (attribute.unit === "integer") {
+    return value.toLocaleString(void 0, {
+      minimumFractionDigits: 0,
+      maximumFractionDigits: 0
+    });
+  }
+  if (attribute.unit === "percentage") {
+    return (value / 100).toLocaleString(void 0, {
+      style: "percent",
+      minimumFractionDigits: decimals,
+      maximumFractionDigits: 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 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 = 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}`);
       }
-      return Promise.resolve(results);
-    },
-    findByAuthId(authId) {
-      for (const profile of stores.userProfiles.values()) {
-        if (profile.authId === authId) {
-          return Promise.resolve(profile);
-        }
+      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 "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 Promise.resolve(null);
-    },
-    findByEmail(email) {
-      const tenantId = getTenantId();
-      for (const profile of stores.userProfiles.values()) {
-        if (profile.tenantId === tenantId && profile.email === email) {
-          return Promise.resolve(profile);
+      return String(value);
+    default: {
+      if (Array.isArray(value)) {
+        return value.join(", ");
+      }
+      return String(value);
+    }
+  }
+}
+
+// src/runtime/template.ts
+var simplePipes = {
+  /** Convert to uppercase */
+  UPPER: (v) => String(v).toUpperCase(),
+  /** Convert to lowercase */
+  LOWER: (v) => String(v).toLowerCase(),
+  /** Capitalize first letter of each word */
+  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
+  /** Trim whitespace from both ends */
+  trim: (v) => String(v).trim()
+};
+var pipesWithArgs = {
+  /** Add prefix only if value is non-empty */
+  prefix: (v, pre = "") => v ? `${pre}${v}` : "",
+  /** Add suffix only if value is non-empty */
+  suffix: (v, suf = "") => v ? `${v}${suf}` : "",
+  /** Wrap value with prefix and suffix only if non-empty */
+  wrap: (v, pre = "", suf = "") => v ? `${pre}${v}${suf}` : "",
+  /** Show default value if empty */
+  default: (v, def = "") => v || def
+};
+function getValue(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc == null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+var DEFAULT_LABEL_FALLBACK = "(Untitled)";
+function parsePipeExpression(pipeExpr) {
+  const match = pipeExpr.match(/^(\w+)(?::(.*))?$/);
+  if (!match) return { name: pipeExpr, args: [] };
+  const name = match[1];
+  const argsStr = match[2];
+  if (!argsStr) return { name, args: [] };
+  const args = [];
+  const argRegex = /["']([^"']*?)["']/g;
+  let argMatch;
+  while ((argMatch = argRegex.exec(argsStr)) !== null) {
+    args.push(argMatch[1]);
+  }
+  return { name, args };
+}
+function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
+  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
+    const parts = expr.split("|").map((s) => s.trim());
+    const path = parts[0];
+    let value = getValue(values, path);
+    const isEmpty3 = value == null || value === "";
+    if (isEmpty3 && parts.length === 1) return "";
+    for (let i = 1; i < parts.length; i++) {
+      const { name: pipeName, args } = parsePipeExpression(parts[i]);
+      const simpleFn = simplePipes[pipeName];
+      if (simpleFn) {
+        if (value != null && value !== "") {
+          value = simpleFn(String(value));
+        }
+      } else {
+        const argFn = pipesWithArgs[pipeName];
+        if (argFn) {
+          value = argFn(String(value ?? ""), ...args);
         }
       }
-      return Promise.resolve(null);
-    },
-    create(data) {
-      const tenantId = getTenantId();
-      const profile = {
-        id: generateId(),
-        tenantId,
-        authId: data.authId,
-        email: data.email,
-        firstName: data.firstName,
-        lastName: data.lastName,
-        avatarUrl: data.avatarUrl,
-        role: data.role ?? "member",
-        status: data.status ?? "active",
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.userProfiles.set(profile.id, profile);
-      return Promise.resolve(profile);
-    },
-    update(id, data) {
-      const existing = stores.userProfiles.get(id);
-      if (!existing) {
-        return Promise.reject(new Error(`UserProfile ${id} not found`));
-      }
-      const updated = {
-        ...existing,
-        ...data,
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.userProfiles.set(id, updated);
-      return Promise.resolve(updated);
-    },
-    delete(id) {
-      stores.userProfiles.delete(id);
-      return Promise.resolve();
-    },
-    list(options) {
-      const tenantId = getTenantId();
-      let results = Array.from(stores.userProfiles.values()).filter((p) => p.tenantId === tenantId);
-      if (options?.limit) {
-        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
-      }
-      return Promise.resolve(results);
-    },
-    countByRole(role) {
-      const tenantId = getTenantId();
-      const count = Array.from(stores.userProfiles.values()).filter(
-        (profile) => profile.tenantId === tenantId && profile.role === role
-      ).length;
-      return Promise.resolve(count);
-    },
-    updateLastLogin(id) {
-      const profile = stores.userProfiles.get(id);
-      if (profile) {
-        profile.lastLoginAt = /* @__PURE__ */ new Date();
-        stores.userProfiles.set(id, profile);
-      }
-      return Promise.resolve();
-    },
-    invite(data) {
-      const tenantId = getTenantId();
-      const profile = {
-        id: generateId(),
-        tenantId,
-        authId: `invited-${generateId()}`,
-        email: data.email,
-        firstName: data.firstName,
-        lastName: data.lastName,
-        role: data.role ?? "member",
-        status: "pending",
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.userProfiles.set(profile.id, profile);
-      return Promise.resolve(profile);
     }
-  };
+    return String(value ?? "");
+  }).trim();
+  return result || fallback;
 }
-function createMockFilesRepository(stores) {
-  return {
-    findById(id) {
-      const file2 = stores.files.get(id);
-      if (file2?.deletedAt) return Promise.resolve(null);
-      return Promise.resolve(file2 ?? null);
-    },
-    findByIds(ids) {
-      const files = ids.map((id) => stores.files.get(id)).filter((f) => f != null && !f.deletedAt);
-      return Promise.resolve(files);
-    },
-    create(data) {
-      const tenantId = getTenantId();
-      const file2 = {
-        id: generateId(),
-        tenantId,
-        name: data.name,
-        originalName: data.originalName,
-        mimeType: data.mimeType,
-        size: data.size,
-        storageProvider: data.storageProvider,
-        storagePath: data.storagePath,
-        storageBucket: data.storageBucket,
-        url: data.url,
-        uploadedBy: data.uploadedBy,
-        folderPath: data.folderPath,
-        tags: data.tags,
-        visibility: data.visibility ?? "private",
-        allowedUsers: data.allowedUsers,
-        createdAt: /* @__PURE__ */ new Date(),
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.files.set(file2.id, file2);
-      return Promise.resolve(file2);
-    },
-    update(id, data) {
-      const existing = stores.files.get(id);
-      if (!existing) {
-        return Promise.reject(new Error(`File ${id} not found`));
-      }
-      const updated = {
-        ...existing,
-        ...data,
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      stores.files.set(id, updated);
-      return Promise.resolve(updated);
-    },
-    delete(id) {
-      const file2 = stores.files.get(id);
-      if (file2) {
-        file2.deletedAt = /* @__PURE__ */ new Date();
-        stores.files.set(id, file2);
-      }
-      return Promise.resolve();
-    },
-    hardDelete(id) {
-      stores.files.delete(id);
-      return Promise.resolve();
-    },
-    list(options) {
-      const tenantId = getTenantId();
-      let results = Array.from(stores.files.values()).filter(
-        (f) => f.tenantId === tenantId && !f.deletedAt
-      );
-      if (options?.mimeType) {
-        results = results.filter((f) => f.mimeType === options.mimeType);
-      }
-      if (options?.limit) {
-        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
-      }
-      return Promise.resolve(results);
-    },
-    findByFolder(folderPath) {
-      const tenantId = getTenantId();
-      const results = Array.from(stores.files.values()).filter(
-        (f) => f.tenantId === tenantId && f.folderPath === folderPath && !f.deletedAt
-      );
-      return Promise.resolve(results);
-    },
-    findByUploader(uploadedBy) {
-      const results = Array.from(stores.files.values()).filter(
-        (f) => f.uploadedBy === uploadedBy && !f.deletedAt
-      );
-      return Promise.resolve(results);
+function isLabelExpression(value) {
+  return /\{\{\s*\S+.*\}\}/.test(value);
+}
+function extractAttributeNames(template) {
+  const names = [];
+  const regex = /\{\{\s*([^|}]+)/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const path = match[1].trim();
+    const rootName = path.split(".")[0];
+    if (rootName && !names.includes(rootName)) {
+      names.push(rootName);
     }
-  };
+  }
+  return names;
+}
+function hasOptions(attr) {
+  return "options" in attr && Array.isArray(attr.options) && attr.options.length > 0;
+}
+var FORMATTABLE_TYPES = /* @__PURE__ */ new Set([
+  "currency",
+  "location",
+  "phone",
+  "date",
+  "rating",
+  "select",
+  "status",
+  "multiselect",
+  "number"
+]);
+function enrichValuesForDisplay(values, attributes) {
+  const enriched = { ...values };
+  for (const attr of attributes) {
+    const value = values[attr.name];
+    if (value == null) continue;
+    if (!FORMATTABLE_TYPES.has(attr.type)) 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;
+}
+var enrichValuesWithSelectLabels = enrichValuesForDisplay;
+function extractRelationIds(val) {
+  if (typeof val === "string") return [val];
+  if (Array.isArray(val) && typeof val[0] === "string") return [val[0]];
+  return [];
+}
+async function computeLabelWithRelations(template, values, attributes, resolveRelationIds) {
+  let enrichedValues = enrichValuesForDisplay(values, attributes);
+  const attrNames = extractAttributeNames(template);
+  const relationAttrs = attributes.filter(
+    (attr) => attr.type === "relation" && attrNames.includes(attr.name)
+  );
+  if (relationAttrs.length === 0) {
+    return renderLabelExpression(template, enrichedValues);
+  }
+  const allIds = [];
+  for (const attr of relationAttrs) {
+    const ids = extractRelationIds(values[attr.name]);
+    allIds.push(...ids);
+  }
+  if (allIds.length === 0) {
+    return renderLabelExpression(template, enrichedValues);
+  }
+  const resolvedMap = await resolveRelationIds(allIds);
+  enrichedValues = { ...enrichedValues };
+  for (const attr of relationAttrs) {
+    const ids = extractRelationIds(values[attr.name]);
+    if (ids.length > 0 && resolvedMap.has(ids[0])) {
+      enrichedValues[attr.name] = resolvedMap.get(ids[0]);
+    }
+  }
+  return renderLabelExpression(template, enrichedValues);
 }
+
+// src/runtime/mock/mock-object-records.ts
 function createMockObjectRecordsRepository(stores) {
   return {
     hardDelete(id) {
@@ -3315,7 +3760,20 @@ function createMockObjectRecordsRepository(stores) {
       if (!existing) {
         return Promise.reject(new Error(`ObjectRecord ${id} not found`));
       }
-      const { __completionStatus, __label, __metadata, __lastUpdatedBy, ...valueData } = data;
+      const {
+        __completionStatus,
+        __label,
+        __metadata,
+        __lastUpdatedBy,
+        __expectedUpdatedAt,
+        ...valueData
+      } = data;
+      if (__expectedUpdatedAt) {
+        const existingUpdatedAt = existing.updatedAt instanceof Date ? existing.updatedAt.toISOString() : String(existing.updatedAt);
+        if (existingUpdatedAt !== __expectedUpdatedAt) {
+          return Promise.reject(new ConcurrentModificationError(id));
+        }
+      }
       const updated = {
         ...existing,
         label: __label ?? existing.label,
@@ -3532,107 +3990,138 @@ function createMockObjectRecordsRepository(stores) {
     }
   };
 }
-function createMockViewsRepository(stores) {
+
+// src/runtime/mock/mock-stores.ts
+function createEmptyStores() {
+  return {
+    objects: /* @__PURE__ */ new Map(),
+    attributes: /* @__PURE__ */ new Map(),
+    userProfiles: /* @__PURE__ */ new Map(),
+    files: /* @__PURE__ */ new Map(),
+    objectRecords: /* @__PURE__ */ new Map(),
+    views: /* @__PURE__ */ new Map(),
+    roles: /* @__PURE__ */ new Map(),
+    permissions: /* @__PURE__ */ new Map(),
+    userRoles: /* @__PURE__ */ new Map(),
+    workflows: /* @__PURE__ */ new Map(),
+    workflowInstances: /* @__PURE__ */ new Map(),
+    workflowInvitations: /* @__PURE__ */ new Map(),
+    workflowAccessGrants: /* @__PURE__ */ new Map(),
+    aiConversations: /* @__PURE__ */ new Map(),
+    aiMessages: /* @__PURE__ */ new Map(),
+    aiUserMemory: /* @__PURE__ */ new Map(),
+    aiUsageMetrics: /* @__PURE__ */ new Map()
+  };
+}
+
+// src/runtime/mock/mock-users.ts
+function createMockUserProfilesRepository(stores) {
   return {
     findById(id) {
-      return Promise.resolve(stores.views.get(id) ?? null);
+      return Promise.resolve(stores.userProfiles.get(id) ?? null);
     },
-    findByName(objectName, viewName) {
+    findByIds(ids) {
       const tenantId = getTenantId();
-      return Promise.resolve(
-        Array.from(stores.views.values()).find(
-          (v) => v.tenantId === tenantId && v.objectName === objectName && v.name === viewName
-        ) ?? null
-      );
+      const results = [];
+      for (const id of ids) {
+        const profile = stores.userProfiles.get(id);
+        if (profile && profile.tenantId === tenantId) {
+          results.push(profile);
+        }
+      }
+      return Promise.resolve(results);
     },
-    findByObjectName(objectName) {
-      const tenantId = getTenantId();
-      return Promise.resolve(
-        Array.from(stores.views.values()).filter(
-          (v) => v.tenantId === tenantId && v.objectName === objectName
-        )
-      );
+    findByAuthId(authId) {
+      for (const profile of stores.userProfiles.values()) {
+        if (profile.authId === authId) {
+          return Promise.resolve(profile);
+        }
+      }
+      return Promise.resolve(null);
     },
-    findAllForTenant() {
+    findByEmail(email) {
       const tenantId = getTenantId();
-      return Promise.resolve(
-        Array.from(stores.views.values()).filter((v) => v.tenantId === tenantId)
-      );
-    },
-    findSystemByName(objectName, viewName) {
-      return Promise.resolve(
-        Array.from(stores.views.values()).find(
-          (v) => v.objectName === objectName && v.name === viewName && v.system
-        ) ?? null
-      );
-    },
-    findSystemByObjectName(objectName) {
-      return Promise.resolve(
-        Array.from(stores.views.values()).filter((v) => v.objectName === objectName && v.system)
-      );
+      for (const profile of stores.userProfiles.values()) {
+        if (profile.tenantId === tenantId && profile.email === email) {
+          return Promise.resolve(profile);
+        }
+      }
+      return Promise.resolve(null);
     },
     create(data) {
       const tenantId = getTenantId();
-      const id = generateId();
-      const now = /* @__PURE__ */ new Date();
-      const dbView = {
-        id,
+      const profile = {
+        id: generateId(),
         tenantId,
-        objectName: data.objectName,
-        name: data.name,
-        label: data.label,
-        description: data.description,
-        icon: data.icon,
-        tabs: data.tabs,
-        default: data.default ?? false,
-        system: data.system ?? false,
-        metadata: data.metadata,
-        createdAt: now,
-        updatedAt: now
+        authId: data.authId,
+        email: data.email,
+        firstName: data.firstName,
+        lastName: data.lastName,
+        avatarUrl: data.avatarUrl,
+        role: data.role ?? "member",
+        status: data.status ?? "active",
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
       };
-      stores.views.set(id, dbView);
-      return Promise.resolve(dbView);
+      stores.userProfiles.set(profile.id, profile);
+      return Promise.resolve(profile);
     },
     update(id, data) {
-      const view2 = stores.views.get(id);
-      if (!view2) {
-        return Promise.reject(new Error(`View not found: ${id}`));
+      const existing = stores.userProfiles.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`UserProfile ${id} not found`));
       }
       const updated = {
-        ...view2,
+        ...existing,
         ...data,
         updatedAt: /* @__PURE__ */ new Date()
       };
-      stores.views.set(id, updated);
+      stores.userProfiles.set(id, updated);
       return Promise.resolve(updated);
     },
     delete(id) {
-      stores.views.delete(id);
+      stores.userProfiles.delete(id);
       return Promise.resolve();
     },
-    deleteNotIn(objectName, keepViewNames) {
-      let deleted = 0;
-      for (const [id, view2] of stores.views.entries()) {
-        if (view2.objectName === objectName && view2.system && !keepViewNames.includes(view2.name)) {
-          stores.views.delete(id);
-          deleted++;
-        }
+    list(options) {
+      const tenantId = getTenantId();
+      let results = Array.from(stores.userProfiles.values()).filter((p) => p.tenantId === tenantId);
+      if (options?.limit) {
+        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
       }
-      return Promise.resolve(deleted);
+      return Promise.resolve(results);
     },
-    async upsert(data) {
-      const existing = data.system ? await this.findSystemByName(data.objectName, data.name) : await this.findByName(data.objectName, data.name);
-      if (existing) {
-        return this.update(existing.id, {
-          label: data.label,
-          description: data.description,
-          icon: data.icon,
-          tabs: data.tabs,
-          default: data.default,
-          metadata: data.metadata
-        });
+    countByRole(role) {
+      const tenantId = getTenantId();
+      const count = Array.from(stores.userProfiles.values()).filter(
+        (profile) => profile.tenantId === tenantId && profile.role === role
+      ).length;
+      return Promise.resolve(count);
+    },
+    updateLastLogin(id) {
+      const profile = stores.userProfiles.get(id);
+      if (profile) {
+        profile.lastLoginAt = /* @__PURE__ */ new Date();
+        stores.userProfiles.set(id, profile);
       }
-      return this.create(data);
+      return Promise.resolve();
+    },
+    invite(data) {
+      const tenantId = getTenantId();
+      const profile = {
+        id: generateId(),
+        tenantId,
+        authId: `invited-${generateId()}`,
+        email: data.email,
+        firstName: data.firstName,
+        lastName: data.lastName,
+        role: data.role ?? "member",
+        status: "pending",
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.userProfiles.set(profile.id, profile);
+      return Promise.resolve(profile);
     }
   };
 }
@@ -3789,10 +4278,118 @@ function createMockPermissionsRepository(stores) {
           }
         }
       }
-      return Promise.resolve({ isAdmin, objectPermissions, systemPermissions });
+      return Promise.resolve({ isAdmin, objectPermissions, systemPermissions });
+    }
+  };
+}
+
+// src/runtime/mock/mock-views.ts
+function createMockViewsRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.views.get(id) ?? null);
+    },
+    findByName(objectName, viewName) {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.views.values()).find(
+          (v) => v.tenantId === tenantId && v.objectName === objectName && v.name === viewName
+        ) ?? null
+      );
+    },
+    findByObjectName(objectName) {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.views.values()).filter(
+          (v) => v.tenantId === tenantId && v.objectName === objectName
+        )
+      );
+    },
+    findAllForTenant() {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.views.values()).filter((v) => v.tenantId === tenantId)
+      );
+    },
+    findSystemByName(objectName, viewName) {
+      return Promise.resolve(
+        Array.from(stores.views.values()).find(
+          (v) => v.objectName === objectName && v.name === viewName && v.system
+        ) ?? null
+      );
+    },
+    findSystemByObjectName(objectName) {
+      return Promise.resolve(
+        Array.from(stores.views.values()).filter((v) => v.objectName === objectName && v.system)
+      );
+    },
+    create(data) {
+      const tenantId = getTenantId();
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const dbView = {
+        id,
+        tenantId,
+        objectName: data.objectName,
+        name: data.name,
+        label: data.label,
+        description: data.description,
+        icon: data.icon,
+        tabs: data.tabs,
+        default: data.default ?? false,
+        system: data.system ?? false,
+        metadata: data.metadata,
+        createdAt: now,
+        updatedAt: now
+      };
+      stores.views.set(id, dbView);
+      return Promise.resolve(dbView);
+    },
+    update(id, data) {
+      const view2 = stores.views.get(id);
+      if (!view2) {
+        return Promise.reject(new Error(`View not found: ${id}`));
+      }
+      const updated = {
+        ...view2,
+        ...data,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.views.set(id, updated);
+      return Promise.resolve(updated);
+    },
+    delete(id) {
+      stores.views.delete(id);
+      return Promise.resolve();
+    },
+    deleteNotIn(objectName, keepViewNames) {
+      let deleted = 0;
+      for (const [id, view2] of stores.views.entries()) {
+        if (view2.objectName === objectName && view2.system && !keepViewNames.includes(view2.name)) {
+          stores.views.delete(id);
+          deleted++;
+        }
+      }
+      return Promise.resolve(deleted);
+    },
+    async upsert(data) {
+      const existing = data.system ? await this.findSystemByName(data.objectName, data.name) : await this.findByName(data.objectName, data.name);
+      if (existing) {
+        return this.update(existing.id, {
+          label: data.label,
+          description: data.description,
+          icon: data.icon,
+          tabs: data.tabs,
+          default: data.default,
+          metadata: data.metadata
+        });
+      }
+      return this.create(data);
     }
   };
 }
+
+// src/runtime/mock/mock-workflows.ts
 function createMockWorkflowsRepository(stores) {
   return {
     findById(id) {
@@ -4038,433 +4635,138 @@ function createMockWorkflowInstancesRepository(stores) {
       if (options?.offset !== void 0 || options?.limit !== void 0) {
         const start = options?.offset ?? 0;
         const end = options?.limit ? start + options.limit : void 0;
-        results = results.slice(start, end);
-      }
-      return Promise.resolve({ instances: results, total });
-    }
-  };
-}
-function createMockWorkflowInvitationsRepository(stores) {
-  return {
-    findById(id) {
-      const invitation = stores.workflowInvitations.get(id);
-      if (!invitation) return Promise.resolve(null);
-      const tenantId = getTenantId();
-      if (invitation.tenant_id !== tenantId) return Promise.resolve(null);
-      return Promise.resolve(invitation);
-    },
-    findByInstanceId(instanceId) {
-      const tenantId = getTenantId();
-      const results = Array.from(stores.workflowInvitations.values()).filter(
-        (inv) => inv.tenant_id === tenantId && inv.instance_id === instanceId
-      );
-      return Promise.resolve(results);
-    },
-    findByEmail(email) {
-      const tenantId = getTenantId();
-      const results = Array.from(stores.workflowInvitations.values()).filter(
-        (inv) => inv.tenant_id === tenantId && inv.recipient_email === email
-      );
-      return Promise.resolve(results);
-    },
-    create(data) {
-      const tenantId = getTenantId();
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const invitation = {
-        id: generateId(),
-        tenant_id: tenantId,
-        instance_id: data.instanceId,
-        recipient_email: data.recipientEmail,
-        recipient_name: data.recipientName ?? null,
-        status: data.status ?? "pending",
-        created_by: data.createdBy,
-        created_at: now,
-        accepted_at: null,
-        expires_at: data.expiresAt.toISOString()
-      };
-      stores.workflowInvitations.set(invitation.id, invitation);
-      return Promise.resolve(invitation);
-    },
-    update(id, data) {
-      const existing = stores.workflowInvitations.get(id);
-      if (!existing) {
-        return Promise.reject(new Error(`WorkflowInvitation ${id} not found`));
-      }
-      const updated = {
-        ...existing,
-        status: data.status ?? existing.status,
-        accepted_at: data.acceptedAt !== void 0 ? data.acceptedAt?.toISOString() ?? null : existing.accepted_at,
-        expires_at: data.expiresAt !== void 0 ? data.expiresAt.toISOString() : existing.expires_at
-      };
-      stores.workflowInvitations.set(id, updated);
-      return Promise.resolve(updated);
-    }
-  };
-}
-function createMockWorkflowAccessGrantsRepository(stores) {
-  return {
-    findById(id) {
-      const grant = stores.workflowAccessGrants.get(id);
-      if (!grant) return Promise.resolve(null);
-      const tenantId = getTenantId();
-      if (grant.tenant_id !== tenantId) return Promise.resolve(null);
-      return Promise.resolve(grant);
-    },
-    findByInvitationId(invitationId) {
-      const tenantId = getTenantId();
-      const results = Array.from(stores.workflowAccessGrants.values()).filter(
-        (g) => g.tenant_id === tenantId && g.invitation_id === invitationId
-      );
-      return Promise.resolve(results);
-    },
-    findByInstanceId(instanceId) {
-      const tenantId = getTenantId();
-      const results = Array.from(stores.workflowAccessGrants.values()).filter(
-        (g) => g.tenant_id === tenantId && g.instance_id === instanceId
-      );
-      return Promise.resolve(results);
-    },
-    findByEmail(email) {
-      const tenantId = getTenantId();
-      const results = Array.from(stores.workflowAccessGrants.values()).filter(
-        (g) => g.tenant_id === tenantId && g.granted_to === email
-      );
-      return Promise.resolve(results);
-    },
-    create(data) {
-      const tenantId = getTenantId();
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      const grant = {
-        id: generateId(),
-        tenant_id: tenantId,
-        invitation_id: data.invitationId,
-        instance_id: data.instanceId,
-        granted_to: data.grantedTo,
-        scope: data.scope ?? ["*"],
-        revoked_token_jtis: data.revokedTokenJtis ?? [],
-        created_at: now,
-        last_used_at: null,
-        valid_until: data.validUntil.toISOString(),
-        revoked_at: null
-      };
-      stores.workflowAccessGrants.set(grant.id, grant);
-      return Promise.resolve(grant);
-    },
-    update(id, data) {
-      const existing = stores.workflowAccessGrants.get(id);
-      if (!existing) {
-        return Promise.reject(new Error(`WorkflowAccessGrant ${id} not found`));
-      }
-      const updated = {
-        ...existing,
-        last_used_at: data.lastUsedAt !== void 0 ? data.lastUsedAt.toISOString() : existing.last_used_at,
-        revoked_token_jtis: data.revokedTokenJtis ?? existing.revoked_token_jtis,
-        revoked_at: data.revokedAt !== void 0 ? data.revokedAt?.toISOString() ?? null : existing.revoked_at
-      };
-      stores.workflowAccessGrants.set(id, updated);
-      return Promise.resolve(updated);
-    }
-  };
-}
-function requireUserId() {
-  const userId = getUserId();
-  if (!userId) {
-    throw new Error("User context required for AI operations");
-  }
-  return userId;
-}
-function createMockAIConversationsRepository(stores) {
-  return {
-    findById(id) {
-      const conversation = stores.aiConversations.get(id);
-      if (!conversation || conversation.deletedAt) return Promise.resolve(null);
-      const tenantId = getTenantId();
-      if (conversation.tenantId !== tenantId) return Promise.resolve(null);
-      return Promise.resolve(conversation);
-    },
-    list(options) {
-      const tenantId = getTenantId();
-      const userId = requireUserId();
-      let results = Array.from(stores.aiConversations.values()).filter((c) => {
-        if (c.tenantId !== tenantId || c.userId !== userId) return false;
-        if (!options?.includeDeleted && c.deletedAt) return false;
-        return true;
-      });
-      results.sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime());
-      const total = results.length;
-      if (options?.limit) {
-        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
-      }
-      return Promise.resolve({ conversations: results, total });
-    },
-    create(data) {
-      const tenantId = getTenantId();
-      const userId = requireUserId();
-      const now = /* @__PURE__ */ new Date();
-      const conversation = {
-        id: generateId(),
-        tenantId,
-        userId,
-        title: data.title ?? null,
-        messageCount: 0,
-        totalTokens: 0,
-        totalCost: 0,
-        createdAt: now,
-        updatedAt: now,
-        deletedAt: null
-      };
-      stores.aiConversations.set(conversation.id, conversation);
-      return Promise.resolve(conversation);
-    },
-    updateTitle(id, title) {
-      const conversation = stores.aiConversations.get(id);
-      if (!conversation || conversation.deletedAt) return Promise.resolve(null);
-      const tenantId = getTenantId();
-      if (conversation.tenantId !== tenantId) return Promise.resolve(null);
-      conversation.title = title;
-      conversation.updatedAt = /* @__PURE__ */ new Date();
-      stores.aiConversations.set(id, conversation);
-      return Promise.resolve(conversation);
-    },
-    delete(id) {
-      const conversation = stores.aiConversations.get(id);
-      if (!conversation) return Promise.resolve(false);
-      const tenantId = getTenantId();
-      if (conversation.tenantId !== tenantId) return Promise.resolve(false);
-      conversation.deletedAt = /* @__PURE__ */ new Date();
-      stores.aiConversations.set(id, conversation);
-      return Promise.resolve(true);
-    },
-    addMessage(input) {
-      const now = /* @__PURE__ */ new Date();
-      const message = {
-        id: generateId(),
-        conversationId: input.conversationId,
-        role: input.role,
-        content: input.content,
-        thinkingLevel: input.thinkingLevel ?? null,
-        thinkingSummary: input.thinkingSummary ?? null,
-        toolCalls: input.toolCalls ?? null,
-        inputTokens: input.inputTokens ?? null,
-        outputTokens: input.outputTokens ?? null,
-        cost: input.cost ?? null,
-        provider: input.provider ?? null,
-        model: input.model ?? null,
-        attachmentIds: input.attachmentIds ?? null,
-        createdAt: now
-      };
-      stores.aiMessages.set(message.id, message);
-      const conversation = stores.aiConversations.get(input.conversationId);
-      if (conversation) {
-        conversation.messageCount++;
-        conversation.totalTokens += (input.inputTokens ?? 0) + (input.outputTokens ?? 0);
-        conversation.totalCost += input.cost ?? 0;
-        conversation.updatedAt = now;
-        stores.aiConversations.set(input.conversationId, conversation);
-      }
-      return Promise.resolve(message);
-    },
-    listMessages(conversationId, options) {
-      let results = Array.from(stores.aiMessages.values()).filter((m) => m.conversationId === conversationId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime());
-      const total = results.length;
-      if (options?.limit) {
-        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
-      }
-      return Promise.resolve({ messages: results, total });
-    },
-    getRecentMessages(conversationId, count = 20) {
-      const results = Array.from(stores.aiMessages.values()).filter((m) => m.conversationId === conversationId).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime()).slice(-count);
-      return Promise.resolve(results);
+        results = results.slice(start, end);
+      }
+      return Promise.resolve({ instances: results, total });
     }
   };
 }
-function createMockAIUserMemoryRepository(stores) {
-  const getKey = () => {
-    const tenantId = getTenantId();
-    const userId = requireUserId();
-    return `${tenantId}:${userId}`;
-  };
+function createMockWorkflowInvitationsRepository(stores) {
   return {
-    get() {
-      const key = getKey();
-      return Promise.resolve(stores.aiUserMemory.get(key) ?? null);
-    },
-    upsert(data) {
-      const key = getKey();
+    findById(id) {
+      const invitation = stores.workflowInvitations.get(id);
+      if (!invitation) return Promise.resolve(null);
       const tenantId = getTenantId();
-      const userId = requireUserId();
-      const now = /* @__PURE__ */ new Date();
-      const existing = stores.aiUserMemory.get(key);
-      const memory = {
-        id: existing?.id ?? generateId(),
-        tenantId,
-        userId,
-        preferences: data.preferences ?? existing?.preferences ?? {},
-        facts: data.facts ?? existing?.facts ?? [],
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now
-      };
-      stores.aiUserMemory.set(key, memory);
-      return Promise.resolve(memory);
+      if (invitation.tenant_id !== tenantId) return Promise.resolve(null);
+      return Promise.resolve(invitation);
     },
-    addFact(fact) {
-      const key = getKey();
+    findByInstanceId(instanceId) {
       const tenantId = getTenantId();
-      const userId = requireUserId();
-      const now = /* @__PURE__ */ new Date();
-      const existing = stores.aiUserMemory.get(key);
-      const memory = {
-        id: existing?.id ?? generateId(),
-        tenantId,
-        userId,
-        preferences: existing?.preferences ?? {},
-        facts: [...existing?.facts ?? [], fact],
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now
-      };
-      stores.aiUserMemory.set(key, memory);
-      return Promise.resolve(memory);
+      const results = Array.from(stores.workflowInvitations.values()).filter(
+        (inv) => inv.tenant_id === tenantId && inv.instance_id === instanceId
+      );
+      return Promise.resolve(results);
     },
-    removeFact(fact) {
-      const key = getKey();
+    findByEmail(email) {
       const tenantId = getTenantId();
-      const userId = requireUserId();
-      const now = /* @__PURE__ */ new Date();
-      const existing = stores.aiUserMemory.get(key);
-      const memory = {
-        id: existing?.id ?? generateId(),
-        tenantId,
-        userId,
-        preferences: existing?.preferences ?? {},
-        facts: (existing?.facts ?? []).filter((f) => f !== fact),
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now
-      };
-      stores.aiUserMemory.set(key, memory);
-      return Promise.resolve(memory);
+      const results = Array.from(stores.workflowInvitations.values()).filter(
+        (inv) => inv.tenant_id === tenantId && inv.recipient_email === email
+      );
+      return Promise.resolve(results);
     },
-    setPreference(prefKey, value) {
-      const memoryKey = getKey();
+    create(data) {
       const tenantId = getTenantId();
-      const userId = requireUserId();
-      const now = /* @__PURE__ */ new Date();
-      const existing = stores.aiUserMemory.get(memoryKey);
-      const memory = {
-        id: existing?.id ?? generateId(),
-        tenantId,
-        userId,
-        preferences: { ...existing?.preferences ?? {}, [prefKey]: value },
-        facts: existing?.facts ?? [],
-        createdAt: existing?.createdAt ?? now,
-        updatedAt: now
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const invitation = {
+        id: generateId(),
+        tenant_id: tenantId,
+        instance_id: data.instanceId,
+        recipient_email: data.recipientEmail,
+        recipient_name: data.recipientName ?? null,
+        status: data.status ?? "pending",
+        created_by: data.createdBy,
+        created_at: now,
+        accepted_at: null,
+        expires_at: data.expiresAt.toISOString()
       };
-      stores.aiUserMemory.set(memoryKey, memory);
-      return Promise.resolve(memory);
+      stores.workflowInvitations.set(invitation.id, invitation);
+      return Promise.resolve(invitation);
     },
-    clear() {
-      const key = getKey();
-      stores.aiUserMemory.delete(key);
-      return Promise.resolve();
+    update(id, data) {
+      const existing = stores.workflowInvitations.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`WorkflowInvitation ${id} not found`));
+      }
+      const updated = {
+        ...existing,
+        status: data.status ?? existing.status,
+        accepted_at: data.acceptedAt !== void 0 ? data.acceptedAt?.toISOString() ?? null : existing.accepted_at,
+        expires_at: data.expiresAt !== void 0 ? data.expiresAt.toISOString() : existing.expires_at
+      };
+      stores.workflowInvitations.set(id, updated);
+      return Promise.resolve(updated);
     }
   };
 }
-function createMockAIUsageMetricsRepository(stores) {
-  const getDateKey = (date2) => {
-    const tenantId = getTenantId();
-    const dateStr = date2.toISOString().split("T")[0];
-    return `${tenantId}:${dateStr}`;
-  };
+function createMockWorkflowAccessGrantsRepository(stores) {
   return {
-    recordUsage(data) {
+    findById(id) {
+      const grant = stores.workflowAccessGrants.get(id);
+      if (!grant) return Promise.resolve(null);
       const tenantId = getTenantId();
-      const now = /* @__PURE__ */ new Date();
-      const key = getDateKey(now);
-      const existing = stores.aiUsageMetrics.get(key);
-      const providerBreakdown = existing?.providerBreakdown ?? {};
-      if (!providerBreakdown[data.provider]) {
-        providerBreakdown[data.provider] = { requests: 0, tokens: 0, cost: 0 };
-      }
-      providerBreakdown[data.provider].requests++;
-      providerBreakdown[data.provider].tokens += data.tokens;
-      providerBreakdown[data.provider].cost += data.cost;
-      const toolUsage = existing?.toolUsage ?? {};
-      if (data.toolName) {
-        toolUsage[data.toolName] = (toolUsage[data.toolName] ?? 0) + 1;
-      }
-      const metrics = {
-        id: existing?.id ?? generateId(),
-        tenantId,
-        date: new Date(now.toISOString().split("T")[0] ?? now.toISOString()),
-        requestCount: (existing?.requestCount ?? 0) + 1,
-        totalTokens: (existing?.totalTokens ?? 0) + data.tokens,
-        totalCost: (existing?.totalCost ?? 0) + data.cost,
-        providerBreakdown,
-        toolUsage
-      };
-      stores.aiUsageMetrics.set(key, metrics);
-      return Promise.resolve();
+      if (grant.tenant_id !== tenantId) return Promise.resolve(null);
+      return Promise.resolve(grant);
     },
-    getByDateRange(startDate, endDate) {
+    findByInvitationId(invitationId) {
       const tenantId = getTenantId();
-      const results = Array.from(stores.aiUsageMetrics.values()).filter((m) => {
-        if (m.tenantId !== tenantId) return false;
-        return m.date >= startDate && m.date <= endDate;
-      });
-      results.sort((a, b) => a.date.getTime() - b.date.getTime());
+      const results = Array.from(stores.workflowAccessGrants.values()).filter(
+        (g) => g.tenant_id === tenantId && g.invitation_id === invitationId
+      );
       return Promise.resolve(results);
     },
-    getCurrentMonthUsage() {
+    findByInstanceId(instanceId) {
       const tenantId = getTenantId();
-      const now = /* @__PURE__ */ new Date();
-      const startOfMonth = new Date(now.getFullYear(), now.getMonth(), 1);
-      const monthMetrics = Array.from(stores.aiUsageMetrics.values()).filter((m) => {
-        if (m.tenantId !== tenantId) return false;
-        return m.date >= startOfMonth;
-      });
-      const aggregated = {
-        requestCount: 0,
-        totalTokens: 0,
-        totalCost: 0,
-        providerBreakdown: {}
+      const results = Array.from(stores.workflowAccessGrants.values()).filter(
+        (g) => g.tenant_id === tenantId && g.instance_id === instanceId
+      );
+      return Promise.resolve(results);
+    },
+    findByEmail(email) {
+      const tenantId = getTenantId();
+      const results = Array.from(stores.workflowAccessGrants.values()).filter(
+        (g) => g.tenant_id === tenantId && g.granted_to === email
+      );
+      return Promise.resolve(results);
+    },
+    create(data) {
+      const tenantId = getTenantId();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const grant = {
+        id: generateId(),
+        tenant_id: tenantId,
+        invitation_id: data.invitationId,
+        instance_id: data.instanceId,
+        granted_to: data.grantedTo,
+        scope: data.scope ?? ["*"],
+        revoked_token_jtis: data.revokedTokenJtis ?? [],
+        created_at: now,
+        last_used_at: null,
+        valid_until: data.validUntil.toISOString(),
+        revoked_at: null
       };
-      for (const m of monthMetrics) {
-        aggregated.requestCount += m.requestCount;
-        aggregated.totalTokens += m.totalTokens;
-        aggregated.totalCost += m.totalCost;
-        for (const [provider, stats] of Object.entries(m.providerBreakdown)) {
-          if (!aggregated.providerBreakdown[provider]) {
-            aggregated.providerBreakdown[provider] = { requests: 0, tokens: 0, cost: 0 };
-          }
-          aggregated.providerBreakdown[provider].requests += stats.requests;
-          aggregated.providerBreakdown[provider].tokens += stats.tokens;
-          aggregated.providerBreakdown[provider].cost += stats.cost;
-        }
+      stores.workflowAccessGrants.set(grant.id, grant);
+      return Promise.resolve(grant);
+    },
+    update(id, data) {
+      const existing = stores.workflowAccessGrants.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`WorkflowAccessGrant ${id} not found`));
       }
-      return Promise.resolve(aggregated);
-    }
-  };
-}
-function createMockAdapter() {
-  const stores = {
-    objects: /* @__PURE__ */ new Map(),
-    attributes: /* @__PURE__ */ new Map(),
-    userProfiles: /* @__PURE__ */ new Map(),
-    files: /* @__PURE__ */ new Map(),
-    objectRecords: /* @__PURE__ */ new Map(),
-    views: /* @__PURE__ */ new Map(),
-    roles: /* @__PURE__ */ new Map(),
-    permissions: /* @__PURE__ */ new Map(),
-    userRoles: /* @__PURE__ */ new Map(),
-    workflows: /* @__PURE__ */ new Map(),
-    workflowInstances: /* @__PURE__ */ new Map(),
-    workflowInvitations: /* @__PURE__ */ new Map(),
-    workflowAccessGrants: /* @__PURE__ */ new Map(),
-    // AI stores
-    aiConversations: /* @__PURE__ */ new Map(),
-    aiMessages: /* @__PURE__ */ new Map(),
-    aiUserMemory: /* @__PURE__ */ new Map(),
-    aiUsageMetrics: /* @__PURE__ */ new Map()
+      const updated = {
+        ...existing,
+        last_used_at: data.lastUsedAt !== void 0 ? data.lastUsedAt.toISOString() : existing.last_used_at,
+        revoked_token_jtis: data.revokedTokenJtis ?? existing.revoked_token_jtis,
+        revoked_at: data.revokedAt !== void 0 ? data.revokedAt?.toISOString() ?? null : existing.revoked_at
+      };
+      stores.workflowAccessGrants.set(id, updated);
+      return Promise.resolve(updated);
+    }
   };
+}
+
+// src/runtime/mock/mock-adapter.ts
+function createMockAdapter() {
+  const stores = createEmptyStores();
   const adapter = {
     objects: createMockObjectsRepository(stores),
     attributes: createMockAttributesRepository(stores),
@@ -4871,8 +5173,6 @@ var SchemaContextAwareRepository = class extends BaseRepository {
     return getSchemaByNameFromContext(objectName);
   }
 };
-var TenantAwareRepository = BaseRepository;
-var TenantAwareService = BaseService;
 
 // src/types/attributes.ts
 var RELATION_TARGET_ANY = "*";
@@ -7306,6 +7606,15 @@ function isSystemAttributeObject(attr) {
 
 // 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}`,
@@ -7527,7 +7836,7 @@ function createTextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
     schema = schema.max(attr.maxLength, messages.maxLength(attr, attr.maxLength));
   }
   if (attr.pattern) {
-    schema = schema.regex(new RegExp(attr.pattern), messages.invalidPattern(attr));
+    schema = schema.regex(getCachedRegex(attr.pattern), messages.invalidPattern(attr));
   }
   return schema;
 }
@@ -7740,7 +8049,7 @@ function createObjectValidator(objectDef) {
     const validator = createAttributeValidator(attr);
     shape[attr.name] = attr.required ? validator : withEmptyToNull(validator);
   }
-  return z5.object(shape).strict();
+  return z5.object(shape).passthrough();
 }
 function validateAttribute(attr, value) {
   const validator = createAttributeValidator(attr);
@@ -7794,7 +8103,7 @@ function createDraftValidator(objectDef) {
     const validator = createAttributeValidator(attr);
     shape[attr.name] = withEmptyToNull(validator);
   }
-  return z5.object(shape).strict();
+  return z5.object(shape).passthrough();
 }
 function validateDraft(objectDef, data) {
   const validator = createDraftValidator(objectDef);
@@ -8362,15 +8671,17 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
    * @param objectId - Object UUID
    * @returns Object ownership info with tenantId and sharingMode
    */
-  async getObjectOwnerInfo(objectId) {
-    const dbObject = await this.adapter.objects.findById(objectId);
-    if (!dbObject) {
-      throw new Error(`Object with id "${objectId}" not found`);
-    }
-    return {
-      tenantId: dbObject.tenantId,
-      sharingMode: dbObject.sharingMode
-    };
+  getObjectOwnerInfo(objectId) {
+    return this.cachedBy("objectOwnerInfo", objectId, async () => {
+      const dbObject = await this.adapter.objects.findById(objectId);
+      if (!dbObject) {
+        throw new Error(`Object with id "${objectId}" not found`);
+      }
+      return {
+        tenantId: dbObject.tenantId,
+        sharingMode: dbObject.sharingMode
+      };
+    });
   }
   /**
    * Invalidate all schema-related cache for the current tenant.
@@ -8537,252 +8848,52 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
       const exists = await this.objectExists(target.object);
       if (!exists) {
         throw new Error(
-          `Relation target object "${target.object}" does not exist. Make sure the object is created before adding a relation to it.`
-        );
-      }
-    }
-  }
-  /**
-   * Find objects that have a relation attribute targeting the given object.
-   * Used to prevent deletion of objects that are relation targets.
-   * Automatically uses tenant context from AsyncLocalStorage.
-   * @internal
-   */
-  async findObjectsWithRelationTo(targetObjectName) {
-    const allObjects = await this.adapter.objects.list();
-    const referencing = [];
-    for (const obj of allObjects) {
-      if (obj.name === targetObjectName) continue;
-      const attrs = await this.adapter.attributes.findByObjectId(obj.id);
-      const hasRelationToTarget = attrs.some((attr) => {
-        if (attr.type !== "relation") return false;
-        const config = attr.config;
-        return config?.targets?.some((t) => t.object === targetObjectName) ?? false;
-      });
-      if (hasRelationToTarget) {
-        referencing.push(obj.name);
-      }
-    }
-    return referencing;
-  }
-  /**
-   * Convert DB attribute to Attribute type
-   * @internal
-   */
-  convertDBAttributeToAttribute(dbAttr) {
-    const baseAttr = {
-      ...dbAttr.config,
-      id: dbAttr.id,
-      name: dbAttr.name,
-      label: dbAttr.label,
-      type: dbAttr.type,
-      required: dbAttr.required,
-      system: dbAttr.system,
-      unique: dbAttr.unique
-    };
-    return baseAttr;
-  }
-};
-
-// src/exceptions.ts
-var SchemaErrorCode = {
-  // Generic
-  UNKNOWN: "SCHEMA_UNKNOWN_ERROR",
-  // Not Found
-  OBJECT_NOT_FOUND: "SCHEMA_OBJECT_NOT_FOUND",
-  ATTRIBUTE_NOT_FOUND: "SCHEMA_ATTRIBUTE_NOT_FOUND",
-  RECORD_NOT_FOUND: "SCHEMA_RECORD_NOT_FOUND",
-  USER_PROFILE_NOT_FOUND: "SCHEMA_USER_PROFILE_NOT_FOUND",
-  FILE_NOT_FOUND: "SCHEMA_FILE_NOT_FOUND",
-  ROLE_NOT_FOUND: "SCHEMA_ROLE_NOT_FOUND",
-  // Validation
-  VALIDATION_FAILED: "SCHEMA_VALIDATION_FAILED",
-  INVALID_ATTRIBUTE_NAME: "SCHEMA_INVALID_ATTRIBUTE_NAME",
-  INVALID_OBJECT_NAME: "SCHEMA_INVALID_OBJECT_NAME",
-  // Protected Resources
-  PROTECTED_OBJECT: "SCHEMA_PROTECTED_OBJECT",
-  PROTECTED_ATTRIBUTE: "SCHEMA_PROTECTED_ATTRIBUTE",
-  PROTECTED_VIEW: "SCHEMA_PROTECTED_VIEW",
-  PROTECTED_ROLE: "SCHEMA_PROTECTED_ROLE",
-  // Permissions
-  FORBIDDEN: "SCHEMA_FORBIDDEN",
-  // Sync
-  SYNC_FAILED: "SCHEMA_SYNC_FAILED",
-  NOT_SYSTEM_OBJECT: "SCHEMA_NOT_SYSTEM_OBJECT",
-  // Duplicates
-  DUPLICATE_OBJECT: "SCHEMA_DUPLICATE_OBJECT",
-  DUPLICATE_ATTRIBUTE: "SCHEMA_DUPLICATE_ATTRIBUTE"
-};
-var SchemaError = class extends Error {
-  constructor(message, code = SchemaErrorCode.UNKNOWN, details) {
-    super(message);
-    this.name = "SchemaError";
-    this.code = code;
-    this.details = details;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      details: this.details
-    };
-  }
-};
-var NotFoundError = class extends SchemaError {
-  constructor(resourceType, resourceId, code = SchemaErrorCode.RECORD_NOT_FOUND) {
-    super(`${resourceType} with id "${resourceId}" not found`, code, {
-      resourceType,
-      resourceId
-    });
-    this.name = "NotFoundError";
-    this.resourceType = resourceType;
-    this.resourceId = resourceId;
-  }
-};
-var ObjectNotFoundError = class extends NotFoundError {
-  constructor(objectId) {
-    super("Object", objectId, SchemaErrorCode.OBJECT_NOT_FOUND);
-    this.name = "ObjectNotFoundError";
-  }
-};
-var AttributeNotFoundError = class extends NotFoundError {
-  constructor(attributeId) {
-    super("Attribute", attributeId, SchemaErrorCode.ATTRIBUTE_NOT_FOUND);
-    this.name = "AttributeNotFoundError";
-  }
-};
-var RecordNotFoundError = class extends NotFoundError {
-  constructor(recordId) {
-    super("Record", recordId, SchemaErrorCode.RECORD_NOT_FOUND);
-    this.name = "RecordNotFoundError";
-  }
-};
-var UserProfileNotFoundError = class extends NotFoundError {
-  constructor(identifier) {
-    super("UserProfile", identifier, SchemaErrorCode.USER_PROFILE_NOT_FOUND);
-    this.name = "UserProfileNotFoundError";
-  }
-};
-var FileNotFoundError = class extends NotFoundError {
-  constructor(fileId) {
-    super("File", fileId, SchemaErrorCode.FILE_NOT_FOUND);
-    this.name = "FileNotFoundError";
-  }
-};
-var ValidationError = class _ValidationError extends SchemaError {
-  constructor(message, errors) {
-    super(message, SchemaErrorCode.VALIDATION_FAILED, { errors });
-    this.name = "ValidationError";
-    this.errors = errors;
-  }
-  /**
-   * Create a validation error from Zod-style errors
-   */
-  static fromZodErrors(errors) {
-    const details = errors.map((err) => ({
-      path: err.path.map(String),
-      message: err.message
-    }));
-    const message = `Validation failed: ${details.map((d) => `${d.path.join(".")}: ${d.message}`).join(", ")}`;
-    return new _ValidationError(message, details);
-  }
-};
-var ProtectedResourceError = class extends SchemaError {
-  constructor(resourceType, resourceName, operation) {
-    const code = resourceType === "object" ? SchemaErrorCode.PROTECTED_OBJECT : resourceType === "view" ? SchemaErrorCode.PROTECTED_VIEW : SchemaErrorCode.PROTECTED_ATTRIBUTE;
-    super(`Cannot ${operation} system ${resourceType} "${resourceName}"`, code, {
-      resourceType,
-      resourceName,
-      operation
-    });
-    this.name = "ProtectedResourceError";
-    this.resourceType = resourceType;
-    this.resourceName = resourceName;
-    this.operation = operation;
-  }
-};
-var SyncError = class extends SchemaError {
-  constructor(objectName, message, cause) {
-    super(`Failed to sync object "${objectName}": ${message}`, SchemaErrorCode.SYNC_FAILED, {
-      objectName,
-      cause: cause?.message
-    });
-    this.name = "SyncError";
-    this.objectName = objectName;
-    this.cause = cause;
-  }
-};
-var NotSystemObjectError = class extends SchemaError {
-  constructor(objectName) {
-    super(
-      `Object "${objectName}" is not marked as system. Native objects must have system=true.`,
-      SchemaErrorCode.NOT_SYSTEM_OBJECT,
-      { objectName }
-    );
-    this.name = "NotSystemObjectError";
-    this.objectName = objectName;
-  }
-};
-var DuplicateError = class extends SchemaError {
-  constructor(resourceType, resourceName) {
-    const code = resourceType === "object" ? SchemaErrorCode.DUPLICATE_OBJECT : SchemaErrorCode.DUPLICATE_ATTRIBUTE;
-    super(
-      `${resourceType === "object" ? "Object" : "Attribute"} "${resourceName}" already exists`,
-      code,
-      { resourceType, resourceName }
-    );
-    this.name = "DuplicateError";
-    this.resourceType = resourceType;
-    this.resourceName = resourceName;
-  }
-};
-function isSchemaError(error2) {
-  return error2 instanceof SchemaError;
-}
-function isNotFoundError(error2) {
-  return error2 instanceof NotFoundError;
-}
-function isValidationError(error2) {
-  return error2 instanceof ValidationError;
-}
-function isProtectedResourceError(error2) {
-  return error2 instanceof ProtectedResourceError;
-}
-var ForbiddenError = class extends SchemaError {
-  constructor(objectName, action, userId) {
-    super(`No ${action} permission on object "${objectName}"`, SchemaErrorCode.FORBIDDEN, {
-      objectName,
-      action,
-      userId
-    });
-    this.name = "ForbiddenError";
-    this.objectName = objectName;
-    this.action = action;
-    this.userId = userId;
-  }
-};
-var ProtectedRoleError = class extends SchemaError {
-  constructor(roleName, operation) {
-    super(`Cannot ${operation} system role "${roleName}"`, SchemaErrorCode.PROTECTED_ROLE, {
-      roleName,
-      operation
-    });
-    this.name = "ProtectedRoleError";
-    this.roleName = roleName;
-    this.operation = operation;
+          `Relation target object "${target.object}" does not exist. Make sure the object is created before adding a relation to it.`
+        );
+      }
+    }
   }
-};
-var RoleNotFoundError = class extends NotFoundError {
-  constructor(roleId) {
-    super("Role", roleId, SchemaErrorCode.ROLE_NOT_FOUND);
-    this.name = "RoleNotFoundError";
+  /**
+   * Find objects that have a relation attribute targeting the given object.
+   * Used to prevent deletion of objects that are relation targets.
+   * Automatically uses tenant context from AsyncLocalStorage.
+   * @internal
+   */
+  async findObjectsWithRelationTo(targetObjectName) {
+    const allObjects = await this.adapter.objects.list();
+    const referencing = [];
+    for (const obj of allObjects) {
+      if (obj.name === targetObjectName) continue;
+      const attrs = await this.adapter.attributes.findByObjectId(obj.id);
+      const hasRelationToTarget = attrs.some((attr) => {
+        if (attr.type !== "relation") return false;
+        const config = attr.config;
+        return config?.targets?.some((t) => t.object === targetObjectName) ?? false;
+      });
+      if (hasRelationToTarget) {
+        referencing.push(obj.name);
+      }
+    }
+    return referencing;
+  }
+  /**
+   * Convert DB attribute to Attribute type
+   * @internal
+   */
+  convertDBAttributeToAttribute(dbAttr) {
+    const baseAttr = {
+      ...dbAttr.config,
+      id: dbAttr.id,
+      name: dbAttr.name,
+      label: dbAttr.label,
+      type: dbAttr.type,
+      required: dbAttr.required,
+      system: dbAttr.system,
+      unique: dbAttr.unique
+    };
+    return baseAttr;
   }
 };
-function isForbiddenError(error2) {
-  return error2 instanceof ForbiddenError;
-}
 
 // src/native/registry.ts
 var NativeObjectRegistryClass = class {
@@ -9165,7 +9276,8 @@ var AuditService = class extends BaseService {
   startFlushTimer() {
     const intervalMs = this.options?.flushIntervalMs ?? 1e3;
     this.flushTimer = setInterval(() => {
-      this.flush().catch(console.error);
+      this.flush().catch(() => {
+      });
     }, intervalMs);
   }
   /**
@@ -9535,6 +9647,11 @@ function createContextForRestore(schema, tenantId, record, metadata) {
 }
 
 // src/runtime/services/record/helpers/rollup-cascade.ts
+async function batchProcess(items, fn, batchSize = 10) {
+  for (let i = 0; i < items.length; i += batchSize) {
+    await Promise.all(items.slice(i, i + batchSize).map(fn));
+  }
+}
 async function preloadSchemas(records, schemaService) {
   const schemasByObjectId = /* @__PURE__ */ new Map();
   if (records.length === 0) {
@@ -9559,29 +9676,25 @@ async function recalculateParentRollups(record, schema, ctx) {
   if (affectedParentIds.length > 0) {
     const parentRecords = await findRecordsByIds(affectedParentIds);
     const parentSchemas = await preloadSchemas(parentRecords, schemaService);
-    await Promise.all(
-      parentRecords.map(async (parentRecord) => {
-        const parentSchema = parentSchemas.get(parentRecord.objectId);
-        if (!parentSchema) return;
-        const rollupAttrs = parentSchema.attributes.filter(
-          (a) => a.type === "rollup"
-        );
-        if (rollupAttrs.length > 0) {
-          await rollupService.recalculateAndUpdate(parentRecord, parentSchema);
-        }
-      })
-    );
+    await batchProcess(parentRecords, async (parentRecord) => {
+      const parentSchema = parentSchemas.get(parentRecord.objectId);
+      if (!parentSchema) return;
+      const rollupAttrs = parentSchema.attributes.filter(
+        (a) => a.type === "rollup"
+      );
+      if (rollupAttrs.length > 0) {
+        await rollupService.recalculateAndUpdate(parentRecord, parentSchema);
+      }
+    });
   }
   const affectedForwardRecords = await rollupService.findRecordsWithForwardRollup(record, schema);
   if (affectedForwardRecords.length > 0) {
     const forwardSchemas = await preloadSchemas(affectedForwardRecords, schemaService);
-    await Promise.all(
-      affectedForwardRecords.map(async (forwardRecord) => {
-        const forwardSchema = forwardSchemas.get(forwardRecord.objectId);
-        if (!forwardSchema) return;
-        await rollupService.recalculateAndUpdate(forwardRecord, forwardSchema);
-      })
-    );
+    await batchProcess(affectedForwardRecords, async (forwardRecord) => {
+      const forwardSchema = forwardSchemas.get(forwardRecord.objectId);
+      if (!forwardSchema) return;
+      await rollupService.recalculateAndUpdate(forwardRecord, forwardSchema);
+    });
   }
 }
 
@@ -9658,8 +9771,40 @@ var RecordQueryService = class extends BaseService {
     let effectiveTotal = result.total;
     if (policy?.canAccessRecord && this.userId) {
       const ctx = buildPolicyContext(schema.name, this.userId, this.tenantId);
-      filteredRecords = result.records.filter((record) => policy.canAccessRecord?.(ctx, record));
-      effectiveTotal = filteredRecords.length;
+      const requestedLimit = effectiveOptions?.limit ?? 20;
+      const requestedOffset = effectiveOptions?.offset ?? 0;
+      const overfetchMultiplier = 5;
+      const batchSize = requestedLimit * overfetchMultiplier;
+      const maxScanRecords = 1e4;
+      const collected = [];
+      let dbOffset = 0;
+      let totalScanned = 0;
+      let exhausted = false;
+      const target = requestedOffset + requestedLimit;
+      while (collected.length < target && totalScanned < maxScanRecords) {
+        const batch = await runWithSchemaContext(
+          [schema],
+          () => this.adapter.objectRecords.list(objectId, {
+            ...effectiveOptions,
+            limit: batchSize,
+            offset: dbOffset
+          })
+        );
+        if (batch.records.length === 0) {
+          exhausted = true;
+          break;
+        }
+        const filtered = batch.records.filter((record) => policy.canAccessRecord?.(ctx, record));
+        collected.push(...filtered);
+        dbOffset += batch.records.length;
+        totalScanned += batch.records.length;
+        if (batch.records.length < batchSize) {
+          exhausted = true;
+          break;
+        }
+      }
+      effectiveTotal = exhausted ? collected.length : Math.max(collected.length, result.total);
+      filteredRecords = collected.slice(requestedOffset, requestedOffset + requestedLimit);
     }
     if (!options?.skipFormulas) {
       return {
@@ -10020,32 +10165,39 @@ var RelationService = class extends BaseService {
     if (filteredTargets.length === 0) {
       return { options: [], hasMore: false, total: 0 };
     }
+    const queryService = this.getQueryServiceOrThrow();
+    const queryOptions = {
+      limit: pageSize,
+      offset: (page - 1) * pageSize,
+      filters: filter
+    };
+    const targetResults = await Promise.all(
+      filteredTargets.map(async (target) => {
+        const objectSchema = await this.schemaService.getObjectSchemaByName(target.object);
+        if (!objectSchema?.id) return { options: [], total: 0 };
+        const objectId = objectSchema.id;
+        const result = query ? await queryService.searchRecords(objectId, query, queryOptions) : await queryService.listRecords(objectId, queryOptions);
+        const options = await Promise.all(
+          result.records.map(async (record) => {
+            const label = await this.resolveLabel(record, objectSchema, target.displayTemplate);
+            return {
+              id: record.id,
+              objectId,
+              objectName: objectSchema.name,
+              objectLabel: objectSchema.label,
+              objectIcon: objectSchema.icon,
+              label
+            };
+          })
+        );
+        return { options, total: result.total };
+      })
+    );
     const allOptions = [];
     let totalCount = 0;
-    for (const target of filteredTargets) {
-      const objectSchema = await this.schemaService.getObjectSchemaByName(target.object);
-      if (!objectSchema?.id) {
-        continue;
-      }
-      const queryOptions = {
-        limit: pageSize,
-        offset: (page - 1) * pageSize,
-        filters: filter
-      };
-      const queryService = this.getQueryServiceOrThrow();
-      const result = query ? await queryService.searchRecords(objectSchema.id, query, queryOptions) : await queryService.listRecords(objectSchema.id, queryOptions);
-      totalCount += result.total;
-      for (const record of result.records) {
-        const label = await this.resolveLabel(record, objectSchema, target.displayTemplate);
-        allOptions.push({
-          id: record.id,
-          objectId: objectSchema.id,
-          objectName: objectSchema.name,
-          objectLabel: objectSchema.label,
-          objectIcon: objectSchema.icon,
-          label
-        });
-      }
+    for (const { options: opts, total } of targetResults) {
+      allOptions.push(...opts);
+      totalCount += total;
     }
     const hasMore = totalCount > page * pageSize;
     return {
@@ -10574,33 +10726,43 @@ var RollupService = class extends BaseService {
   async findRecordsWithForwardRollup(changedRecord, changedSchema) {
     const affectedRecords = [];
     const allObjects = await this.adapter.objects.list();
-    for (const obj of allObjects) {
-      if (obj.id === changedRecord.objectId) {
-        continue;
+    const objectMap = new Map(allObjects.map((obj) => [obj.id, obj]));
+    const candidateObjectIds = allObjects.filter((obj) => obj.id !== changedRecord.objectId).map((obj) => obj.id);
+    if (candidateObjectIds.length === 0) {
+      return [];
+    }
+    const attrResults = await Promise.all(
+      candidateObjectIds.map(async (objId) => {
+        const attributes = await this.adapter.attributes.findByObjectId(objId);
+        return { objId, attributes };
+      })
+    );
+    const objectsWithRollups = [];
+    for (const { objId, attributes } of attrResults) {
+      const hasRollup = attributes.some((a) => a.type === "rollup");
+      if (hasRollup) {
+        objectsWithRollups.push({ objId, attributes });
       }
-      const attributes = await this.adapter.attributes.findByObjectId(obj.id);
+    }
+    if (objectsWithRollups.length === 0) {
+      return [];
+    }
+    for (const { objId, attributes } of objectsWithRollups) {
       const rollupAttrs = attributes.filter((a) => a.type === "rollup");
-      if (rollupAttrs.length === 0) {
-        continue;
-      }
+      const obj = objectMap.get(objId);
+      if (!obj) continue;
       for (const rollupDbAttr of rollupAttrs) {
         const rollupConfig = rollupDbAttr.config;
-        if (!rollupConfig?.relationAttribute) {
-          continue;
-        }
+        if (!rollupConfig?.relationAttribute) continue;
         const relationAttr = attributes.find(
           (a) => a.type === "relation" && a.name === rollupConfig.relationAttribute
         );
-        if (!relationAttr) {
-          continue;
-        }
+        if (!relationAttr) continue;
         const relationConfig = relationAttr.config;
         const targetsChangedObject = relationConfig?.targets?.some(
           (t) => t.object === changedSchema.name
         );
-        if (!targetsChangedObject) {
-          continue;
-        }
+        if (!targetsChangedObject) continue;
         const recordsPointingToChanged = await this.adapter.objectRecords.findByRelation(
           obj.id,
           relationAttr.name,
@@ -10712,11 +10874,9 @@ var RecordService = class extends BaseService {
       await this.hookRegistry.execute("afterCreate", schema.name, afterCtx);
     }
     await recalculateParentRollups(record, schema, this.rollupContext);
-    await this.invalidateLists("allRecordLists", objectId);
-    await this.invalidateLists("allSearchResults", objectId);
-    await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
+    await this.invalidateRecordCaches(record.id, objectId);
     if (this.auditService && this.userId) {
-      await this.auditService.logRecordAction({
+      this.auditService.logRecordAction({
         action: "record.created",
         actorId: this.userId,
         objectName: schema.name,
@@ -10724,6 +10884,11 @@ var RecordService = class extends BaseService {
         recordId: record.id,
         recordLabel: record.label,
         metadata: options?.hookMetadata
+      }).catch((err) => {
+        console.error(
+          "Audit log failed (record.created):",
+          err instanceof Error ? err.message : err
+        );
       });
     }
     return record;
@@ -10800,7 +10965,19 @@ var RecordService = class extends BaseService {
       checkRecordModifyOrThrow(policy, existing, ctx);
     }
     const mergedData = { ...existing.values, ...data };
-    const changedAttributes = Object.keys(data).filter((key) => existing.values[key] !== data[key]);
+    const changedAttributes = Object.keys(data).filter((key) => {
+      const oldVal = existing.values[key];
+      const newVal = data[key];
+      if (oldVal === newVal) return false;
+      if (oldVal !== null && newVal !== null && typeof oldVal === "object" && typeof newVal === "object") {
+        try {
+          return JSON.stringify(oldVal) !== JSON.stringify(newVal);
+        } catch {
+          return true;
+        }
+      }
+      return true;
+    });
     const hookCtx = createContextForUpdate(
       schema,
       this.tenantId,
@@ -10844,7 +11021,8 @@ var RecordService = class extends BaseService {
       ...hookModifiedValues,
       __completionStatus: completionStatus,
       __label: label,
-      __lastUpdatedBy: this.userId
+      __lastUpdatedBy: this.userId,
+      __expectedUpdatedAt: existing.updatedAt instanceof Date ? existing.updatedAt.toISOString() : existing.updatedAt
     };
     if (options?.metadata !== void 0) {
       const existingMetadata = existing.metadata ?? {};
@@ -10855,10 +11033,7 @@ var RecordService = class extends BaseService {
       updatePayload.__metadata = cleanedMetadata;
     }
     const updated = await this.adapter.objectRecords.update(recordId, updatePayload);
-    await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
-    await this.invalidateLists("allRecordLists", existing.objectId);
-    await this.invalidateLists("allSearchResults", existing.objectId);
-    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    await this.invalidateRecordCaches(recordId, existing.objectId);
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -10877,7 +11052,7 @@ var RecordService = class extends BaseService {
         oldValue: hookCtx.oldValues?.[attr],
         newValue: hookCtx.newValues[attr]
       }));
-      await this.auditService.logRecordAction({
+      this.auditService.logRecordAction({
         action: "record.updated",
         actorId: this.userId,
         objectName: schema.name,
@@ -10886,6 +11061,11 @@ var RecordService = class extends BaseService {
         recordLabel: updated.label,
         changes,
         metadata: options?.hookMetadata
+      }).catch((err) => {
+        console.error(
+          "Audit log failed (record.updated):",
+          err instanceof Error ? err.message : err
+        );
       });
     }
     return updated;
@@ -10929,17 +11109,13 @@ var RecordService = class extends BaseService {
       await this.hookRegistry.execute("beforeDelete", schema.name, hookCtx);
     }
     await this.adapter.objectRecords.delete(recordId);
-    await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
-    await this.invalidateLists("allRecordLists", record.objectId);
-    await this.invalidateLists("allSearchResults", record.objectId);
-    await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
-    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    await this.invalidateRecordCaches(recordId, record.objectId);
     if (!options?.skipHooks) {
       await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
     }
     await recalculateParentRollups(record, schema, this.rollupContext);
     if (this.auditService && this.userId) {
-      await this.auditService.logRecordAction({
+      this.auditService.logRecordAction({
         action: "record.deleted",
         actorId: this.userId,
         objectName: schema.name,
@@ -10947,6 +11123,11 @@ var RecordService = class extends BaseService {
         recordId: record.id,
         recordLabel: record.label,
         metadata: options?.hookMetadata
+      }).catch((err) => {
+        console.error(
+          "Audit log failed (record.deleted):",
+          err instanceof Error ? err.message : err
+        );
       });
     }
   }
@@ -10958,11 +11139,7 @@ var RecordService = class extends BaseService {
     const schema = await this.schemaService.getObjectSchema(record.objectId);
     await checkPermission(this.permissionService, this.userId, schema.name, "delete");
     await this.adapter.objectRecords.hardDelete(recordId);
-    await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
-    await this.invalidateLists("allRecordLists", record.objectId);
-    await this.invalidateLists("allSearchResults", record.objectId);
-    await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
-    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    await this.invalidateRecordCaches(recordId, record.objectId);
   }
   // ============================================================================
   // RESTORE
@@ -10993,11 +11170,7 @@ var RecordService = class extends BaseService {
       await this.hookRegistry.execute("beforeRestore", schema.name, hookCtx);
     }
     const restored = await this.adapter.objectRecords.restore(recordId);
-    await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
-    await this.invalidateLists("allRecordLists", record.objectId);
-    await this.invalidateLists("allSearchResults", record.objectId);
-    await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
-    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+    await this.invalidateRecordCaches(recordId, record.objectId);
     if (!options?.skipHooks) {
       const afterCtx = {
         ...hookCtx,
@@ -11006,7 +11179,7 @@ var RecordService = class extends BaseService {
       await this.hookRegistry.execute("afterRestore", schema.name, afterCtx);
     }
     if (this.auditService && this.userId) {
-      await this.auditService.logRecordAction({
+      this.auditService.logRecordAction({
         action: "record.restored",
         actorId: this.userId,
         objectName: schema.name,
@@ -11014,11 +11187,30 @@ var RecordService = class extends BaseService {
         recordId: restored.id,
         recordLabel: restored.label,
         metadata: options?.hookMetadata
+      }).catch((err) => {
+        console.error(
+          "Audit log failed (record.restored):",
+          err instanceof Error ? err.message : err
+        );
       });
     }
     return restored;
   }
   // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
+  /**
+   * Invalidate all caches related to a record (record cache + lists + global search)
+   * @private
+   */
+  async invalidateRecordCaches(recordId, objectId) {
+    await this.invalidateCache(cacheKeys.record(this.tenantId, recordId));
+    await this.invalidateLists("allRecordLists", objectId);
+    await this.invalidateLists("allSearchResults", objectId);
+    await this.invalidateCachePattern(cacheKeys.allGlobalSearch(this.tenantId));
+    await this.invalidateCachePattern(cacheKeys.resolvedRelationsByRecord(this.tenantId, recordId));
+  }
+  // ============================================================================
   // LIST & SEARCH (delegated to RecordQueryService)
   // ============================================================================
   /**
@@ -11426,8 +11618,7 @@ var DocumentRendererService = class {
           const field = fields.find((f) => f.id === fieldId);
           resolved.set(fieldId, labels.join(", ") || field?.fallback || "");
         }
-      } catch (error2) {
-        console.warn("Failed to resolve relations:", error2);
+      } catch {
         for (const { fieldId, ids } of relationBatch) {
           const field = fields.find((f) => f.id === fieldId);
           resolved.set(fieldId, ids.join(", ") || field?.fallback || "");
@@ -11482,7 +11673,6 @@ var DocumentRendererService = class {
   drawField(pages, field, value, font, fontBold) {
     const page = pages[field.page];
     if (!page) {
-      console.warn(`Field "${field.id}" references non-existent page ${field.page}`);
       return;
     }
     if (!value) {
@@ -11637,7 +11827,6 @@ var DocumentProcessingHook = class extends BaseService {
           ...doc,
           metadata: { ...metadata, status: "failed", error: errorMessage }
         };
-        console.error(`Failed to process document for node ${nodeId}:`, error2);
       }
     }
     return {
@@ -11708,13 +11897,11 @@ var DocumentProcessingHook = class extends BaseService {
       try {
         const recordId = context.createdRecordIds?.[slotId];
         if (!recordId) {
-          console.warn(`No record ID found for slot "${slotId}", skipping attachment`);
           continue;
         }
         const slotDef = workflow2.slots?.find((s) => s.id === slotId);
         const objectName = slotDef?.objectName;
         if (!objectName) {
-          console.warn(`No object name found for slot "${slotId}", skipping attachment`);
           continue;
         }
         const result = await documentService.createRecordDocument({
@@ -11737,8 +11924,7 @@ var DocumentProcessingHook = class extends BaseService {
             { partial: true }
           );
         }
-      } catch (error2) {
-        console.error(`Failed to attach document to slot "${slotId}":`, error2);
+      } catch {
       }
     }
     return attachedDocumentIds;
@@ -12045,6 +12231,7 @@ var WorkflowAccessGrantService = class extends BaseService {
 };
 
 // src/runtime/services/workflow/instance.service.ts
+import { randomUUID } from "crypto";
 var WorkflowInstanceService = class extends BaseService {
   constructor(adapter, workflowService, options) {
     super(adapter);
@@ -12094,7 +12281,24 @@ var WorkflowInstanceService = class extends BaseService {
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const updatedInstance = await this.executeCurrentNode(instance);
+    let updatedInstance;
+    try {
+      updatedInstance = await this.executeCurrentNode(instance);
+    } catch (error2) {
+      updatedInstance = {
+        ...instance,
+        status: "failed",
+        error: {
+          code: "UNEXPECTED_ERROR",
+          message: error2 instanceof Error ? error2.message : String(error2),
+          nodeId: instance.currentNodeId,
+          timestamp: /* @__PURE__ */ new Date()
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.saveInstance(updatedInstance);
+      throw error2;
+    }
     await this.saveInstance(updatedInstance);
     return updatedInstance;
   }
@@ -12106,6 +12310,12 @@ var WorkflowInstanceService = class extends BaseService {
     if (!instance) {
       throw new SchemaError(`Instance "${instanceId}" not found`, SchemaErrorCode.RECORD_NOT_FOUND);
     }
+    if (instance.expiresAt && new Date(instance.expiresAt) < /* @__PURE__ */ new Date()) {
+      throw new SchemaError(
+        `Instance "${instanceId}" has expired (expiresAt: ${instance.expiresAt.toISOString()})`,
+        SchemaErrorCode.VALIDATION_FAILED
+      );
+    }
     if (instance.status !== "waiting") {
       throw new SchemaError(
         `Instance "${instanceId}" is not waiting (status: ${instance.status})`,
@@ -12117,7 +12327,24 @@ var WorkflowInstanceService = class extends BaseService {
       status: "running",
       updatedAt: /* @__PURE__ */ new Date()
     };
-    const result = await this.executeCurrentNode(updatedInstance, input.input);
+    let result;
+    try {
+      result = await this.executeCurrentNode(updatedInstance, input.input);
+    } catch (error2) {
+      result = {
+        ...updatedInstance,
+        status: "failed",
+        error: {
+          code: "UNEXPECTED_ERROR",
+          message: error2 instanceof Error ? error2.message : String(error2),
+          nodeId: updatedInstance.currentNodeId,
+          timestamp: /* @__PURE__ */ new Date()
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.saveInstance(result);
+      throw error2;
+    }
     await this.saveInstance(result);
     return result;
   }
@@ -12146,7 +12373,8 @@ var WorkflowInstanceService = class extends BaseService {
     return updatedInstance;
   }
   /**
-   * Get an instance by ID
+   * Get an instance by ID.
+   * Automatically marks expired instances as "failed" if their expiresAt has passed.
    */
   async getInstance(id) {
     if (!this.adapter.workflowInstances) {
@@ -12156,7 +12384,22 @@ var WorkflowInstanceService = class extends BaseService {
     if (!dbInstance) {
       return null;
     }
-    return this.convertDBInstanceToInstance(dbInstance);
+    let instance = this.convertDBInstanceToInstance(dbInstance);
+    if (instance.expiresAt && new Date(instance.expiresAt) < /* @__PURE__ */ new Date() && !["completed", "failed", "cancelled"].includes(instance.status)) {
+      instance = {
+        ...instance,
+        status: "failed",
+        error: {
+          code: "WORKFLOW_EXPIRED",
+          message: `Workflow instance expired (expiresAt: ${instance.expiresAt.toISOString()})`,
+          nodeId: instance.currentNodeId,
+          timestamp: /* @__PURE__ */ new Date()
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      await this.saveInstance(instance);
+    }
+    return instance;
   }
   /**
    * Get all instances for a workflow
@@ -12179,17 +12422,17 @@ var WorkflowInstanceService = class extends BaseService {
       return { instances: [], total: 0 };
     }
     if (options?.workflowName) {
-      const instances2 = await this.getInstancesByWorkflow(options.workflowName);
-      let filtered = instances2;
-      if (options.status) {
-        filtered = instances2.filter((i) => i.status === options.status);
-      }
-      const total2 = filtered.length;
-      const paginated = filtered.slice(
-        options.offset ?? 0,
-        options.limit ? (options.offset ?? 0) + options.limit : void 0
+      const allDbInstances = await this.adapter.workflowInstances.findByWorkflowName(
+        options.workflowName,
+        { status: options.status }
       );
-      return { instances: paginated, total: total2 };
+      const total2 = allDbInstances.length;
+      const offset = options.offset ?? 0;
+      const limit = options.limit ?? total2;
+      const paged = allDbInstances.slice(offset, offset + limit);
+      let instances2 = paged.map((db) => this.convertDBInstanceToInstance(db));
+      instances2 = await this.markExpiredInstances(instances2);
+      return { instances: instances2, total: total2 };
     }
     const { instances: dbInstances, total } = await this.adapter.workflowInstances.list({
       limit: options?.limit,
@@ -12199,6 +12442,7 @@ var WorkflowInstanceService = class extends BaseService {
     if (options?.status) {
       instances = instances.filter((i) => i.status === options.status);
     }
+    instances = await this.markExpiredInstances(instances);
     return { instances, total };
   }
   /**
@@ -12240,7 +12484,30 @@ var WorkflowInstanceService = class extends BaseService {
    * Execute the current node and continue until wait/complete/error
    */
   async executeCurrentNode(instance, input) {
-    let current = instance;
+    if (instance.expiresAt && new Date(instance.expiresAt) < /* @__PURE__ */ new Date()) {
+      return {
+        ...instance,
+        status: "failed",
+        error: {
+          code: "WORKFLOW_EXPIRED",
+          message: `Workflow instance expired (expiresAt: ${instance.expiresAt.toISOString()})`,
+          nodeId: instance.currentNodeId,
+          timestamp: /* @__PURE__ */ new Date()
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    }
+    const executionId = randomUUID();
+    let current = {
+      ...instance,
+      context: {
+        ...instance.context,
+        variables: {
+          ...instance.context.variables,
+          __lastExecutionId: executionId
+        }
+      }
+    };
     let nodeInput = input;
     while (current.status === "running") {
       const node = current.workflowSnapshot.nodes[current.currentNodeId];
@@ -12256,11 +12523,26 @@ var WorkflowInstanceService = class extends BaseService {
           }
         };
       }
+      let objectDefinitions;
+      if (this.schemaService) {
+        try {
+          const schemas = await Promise.all(
+            current.workflowSnapshot.slots.map(
+              (slot) => this.schemaService?.getObjectSchemaByName(slot.objectName)
+            )
+          );
+          objectDefinitions = schemas.filter(
+            (s) => s !== void 0
+          );
+        } catch {
+        }
+      }
       const executorContext = {
         instance: current,
         definition: current.workflowSnapshot,
         executionContext: current.context,
-        input: nodeInput
+        input: nodeInput,
+        objectDefinitions
       };
       const startTime = Date.now();
       const result = await this.executorRegistry.execute(node, executorContext);
@@ -12302,22 +12584,36 @@ var WorkflowInstanceService = class extends BaseService {
           break;
         }
         case "complete": {
-          let updatedContext = await this.persistSlots(current);
-          if (this.documentProcessingHook) {
-            updatedContext = await this.documentProcessingHook.process(
-              updatedContext,
-              current.workflowSnapshot,
-              current.startedBy
-            );
+          try {
+            let updatedContext = await this.persistSlots(current);
+            if (this.documentProcessingHook) {
+              updatedContext = await this.documentProcessingHook.process(
+                updatedContext,
+                current.workflowSnapshot,
+                current.startedBy
+              );
+            }
+            current = {
+              ...current,
+              context: updatedContext,
+              status: "completed",
+              pendingAction: void 0,
+              updatedAt: /* @__PURE__ */ new Date(),
+              completedAt: /* @__PURE__ */ new Date()
+            };
+          } catch (persistError) {
+            current = {
+              ...current,
+              status: "failed",
+              error: {
+                code: "PERSIST_SLOTS_FAILED",
+                message: persistError instanceof Error ? persistError.message : String(persistError),
+                nodeId: current.currentNodeId,
+                timestamp: /* @__PURE__ */ new Date()
+              },
+              updatedAt: /* @__PURE__ */ new Date()
+            };
           }
-          current = {
-            ...current,
-            context: updatedContext,
-            status: "completed",
-            pendingAction: void 0,
-            updatedAt: /* @__PURE__ */ new Date(),
-            completedAt: /* @__PURE__ */ new Date()
-          };
           break;
         }
         case "error": {
@@ -12341,6 +12637,34 @@ var WorkflowInstanceService = class extends BaseService {
   // ============================================================================
   // HELPERS
   // ============================================================================
+  /**
+   * Check a list of instances for expiration and mark any expired non-terminal
+   * instances as "failed". Saves updated instances to the database.
+   */
+  async markExpiredInstances(instances) {
+    const now = /* @__PURE__ */ new Date();
+    const terminalStatuses = ["completed", "failed", "cancelled"];
+    return await Promise.all(
+      instances.map(async (instance) => {
+        if (instance.expiresAt && new Date(instance.expiresAt) < now && !terminalStatuses.includes(instance.status)) {
+          const expired = {
+            ...instance,
+            status: "failed",
+            error: {
+              code: "WORKFLOW_EXPIRED",
+              message: `Workflow instance expired (expiresAt: ${instance.expiresAt.toISOString()})`,
+              nodeId: instance.currentNodeId,
+              timestamp: now
+            },
+            updatedAt: now
+          };
+          await this.saveInstance(expired);
+          return expired;
+        }
+        return instance;
+      })
+    );
+  }
   mergeContext(base, updates) {
     if (!updates) {
       return base;
@@ -12364,11 +12688,15 @@ var WorkflowInstanceService = class extends BaseService {
   // SLOT PERSISTENCE
   // ============================================================================
   /**
-   * Persist all slots as records in the database.
+   * Persist all slots as records in the database using a saga pattern.
    * - Slots with mode "create" create new records
    * - Slots with mode "select" or "optional" with existing ID update the record
    * - Slots with mode "optional" without ID create new records
    *
+   * If any slot fails to persist, all previously persisted slots in this batch
+   * are rolled back (best-effort): created records are deleted, updated records
+   * are restored to their previous state.
+   *
    * Returns updated context with createdRecordIds populated.
    */
   async persistSlots(instance) {
@@ -12379,6 +12707,7 @@ var WorkflowInstanceService = class extends BaseService {
     const context = { ...instance.context };
     const createdRecordIds = { ...context.createdRecordIds };
     const sortedSlots = this.sortSlotsByDependencies(slots, context);
+    const completedOperations = [];
     for (const slot of sortedSlots) {
       const slotData = context.slots[slot.id];
       if (!slotData) continue;
@@ -12398,17 +12727,36 @@ var WorkflowInstanceService = class extends BaseService {
             }
           });
           createdRecordIds[slot.id] = record.id;
+          completedOperations.push({
+            slotId: slot.id,
+            recordId: record.id,
+            operation: "create"
+          });
         } else if (slot.mode === "select" && existingId) {
+          const previousData = await this.snapshotRecord(existingId);
           await this.recordService.updateRecord(existingId, dataToSave, {
             partial: true
           });
           createdRecordIds[slot.id] = existingId;
+          completedOperations.push({
+            slotId: slot.id,
+            recordId: existingId,
+            operation: "update",
+            previousData
+          });
         } else if (slot.mode === "optional") {
           if (existingId) {
+            const previousData = await this.snapshotRecord(existingId);
             await this.recordService.updateRecord(existingId, dataToSave, {
               partial: true
             });
             createdRecordIds[slot.id] = existingId;
+            completedOperations.push({
+              slotId: slot.id,
+              recordId: existingId,
+              operation: "update",
+              previousData
+            });
           } else {
             const record = await this.recordService.createRecord(objectId, dataToSave, {
               allowDraft: true,
@@ -12418,11 +12766,18 @@ var WorkflowInstanceService = class extends BaseService {
               }
             });
             createdRecordIds[slot.id] = record.id;
+            completedOperations.push({
+              slotId: slot.id,
+              recordId: record.id,
+              operation: "create"
+            });
           }
         }
       } catch (error2) {
+        const rolledBackSlots = await this.rollbackSlotOperations(completedOperations);
+        const rollbackInfo = rolledBackSlots.length > 0 ? ` Rolled back slots: [${rolledBackSlots.join(", ")}].` : "";
         throw new SchemaError(
-          `Failed to persist slot "${slot.id}" (${slot.objectName}): ${error2 instanceof Error ? error2.message : String(error2)}`,
+          `Failed to persist slot "${slot.id}" (${slot.objectName}): ${error2 instanceof Error ? error2.message : String(error2)}.${rollbackInfo}`,
           SchemaErrorCode.VALIDATION_FAILED
         );
       }
@@ -12432,6 +12787,48 @@ var WorkflowInstanceService = class extends BaseService {
       createdRecordIds
     };
   }
+  /**
+   * Snapshot a record's current data for potential rollback.
+   * Returns the record data or undefined if the record cannot be read.
+   */
+  async snapshotRecord(recordId) {
+    try {
+      const record = await this.recordService?.getRecord(recordId, { skipPolicyCheck: true });
+      return record?.values;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Rollback completed slot persistence operations in reverse order (saga compensation).
+   *
+   * This is BEST EFFORT: errors during rollback are logged but never re-thrown.
+   * - For "create" operations: deletes the created record
+   * - For "update" operations: restores the previous data snapshot
+   *
+   * @returns Array of slot IDs that were successfully rolled back
+   */
+  async rollbackSlotOperations(operations) {
+    const rolledBack = [];
+    for (const op of [...operations].reverse()) {
+      try {
+        if (op.operation === "create") {
+          await this.recordService?.deleteRecord(op.recordId, {
+            skipHooks: true,
+            skipReferenceCheck: true
+          });
+          rolledBack.push(op.slotId);
+        } else if (op.operation === "update" && op.previousData) {
+          await this.recordService?.updateRecord(op.recordId, op.previousData, {
+            partial: false
+          });
+          rolledBack.push(op.slotId);
+        }
+      } catch {
+      }
+    }
+    return rolledBack;
+  }
   /**
    * Clean slot data by removing undefined and null values.
    * This prevents form submissions from overwriting existing record values
@@ -12546,18 +12943,30 @@ var WorkflowInstanceService = class extends BaseService {
     if (!this.adapter.workflowInstances) {
       return;
     }
+    const currentVersion = instance.context.variables?.__version ?? 0;
+    const nextVersion = currentVersion + 1;
+    const instanceWithVersion = {
+      ...instance,
+      context: {
+        ...instance.context,
+        variables: {
+          ...instance.context.variables,
+          __version: nextVersion
+        }
+      }
+    };
     await this.adapter.workflowInstances.upsert({
-      id: instance.id,
-      workflowId: instance.workflowId,
-      workflowVersion: instance.workflowVersion,
-      workflowSnapshot: instance.workflowSnapshot,
-      status: instance.status,
-      currentNodeId: instance.currentNodeId,
-      context: instance.context,
-      history: instance.history,
-      pendingAction: instance.pendingAction,
-      startedBy: instance.startedBy,
-      expiresAt: instance.expiresAt
+      id: instanceWithVersion.id,
+      workflowId: instanceWithVersion.workflowId,
+      workflowVersion: instanceWithVersion.workflowVersion,
+      workflowSnapshot: instanceWithVersion.workflowSnapshot,
+      status: instanceWithVersion.status,
+      currentNodeId: instanceWithVersion.currentNodeId,
+      context: instanceWithVersion.context,
+      history: instanceWithVersion.history,
+      pendingAction: instanceWithVersion.pendingAction,
+      startedBy: instanceWithVersion.startedBy,
+      expiresAt: instanceWithVersion.expiresAt
     });
   }
   convertDBInstanceToInstance(db) {
@@ -14823,6 +15232,13 @@ var FileService = class extends BaseService {
         "StorageAdapter is not configured. Provide adapter.storage to use uploadFile()."
       );
     }
+    if (input.folderPath) {
+      let sanitized = input.folderPath;
+      while (sanitized.includes("..")) {
+        sanitized = sanitized.replace(/\.\./g, "");
+      }
+      input.folderPath = sanitized.replace(/^\/+/, "").replace(/\/+/g, "/");
+    }
     const uploadResult = await this.adapter.storage.upload({
       content: input.content,
       fileName: input.fileName,
@@ -15036,29 +15452,36 @@ var FileService = class extends BaseService {
    * @param options - Delete options
    */
   async bulkDelete(fileIds, options) {
-    for (const fileId of fileIds) {
-      const file2 = await this.getFile(fileId);
-      if (!file2) {
-        continue;
-      }
-      if (options?.deleteFromStorage && this.adapter.storage) {
-        await this.adapter.storage.delete(file2.storagePath);
-      }
-      if (options?.hard) {
-        await this.adapter.files.hardDelete(fileId);
-      } else {
-        await this.adapter.files.delete(fileId);
-      }
-      if (this.auditService && this.userId) {
-        await this.auditService.logFileAction({
-          action: "file.deleted",
-          actorId: this.userId,
-          fileId,
-          fileName: file2.name,
-          metadata: { deletedFromStorage: options?.deleteFromStorage ?? false }
-        });
+    if (fileIds.length === 0) return;
+    const fileResults = await Promise.all(fileIds.map((id) => this.getFile(id)));
+    const files = fileResults.filter((f) => f !== null);
+    if (files.length === 0) return;
+    if (options?.deleteFromStorage && this.adapter.storage) {
+      const BATCH_SIZE = 10;
+      for (let i = 0; i < files.length; i += BATCH_SIZE) {
+        const batch = files.slice(i, i + BATCH_SIZE);
+        await Promise.all(batch.map((file2) => this.adapter.storage?.delete(file2.storagePath)));
       }
     }
+    const idsToDelete = files.map((f) => f.id);
+    if (options?.hard) {
+      await Promise.all(idsToDelete.map((id) => this.adapter.files.hardDelete(id)));
+    } else {
+      await Promise.all(idsToDelete.map((id) => this.adapter.files.delete(id)));
+    }
+    if (this.auditService && this.userId) {
+      await Promise.all(
+        files.map(
+          (file2) => this.auditService?.logFileAction({
+            action: "file.deleted",
+            actorId: this.userId ?? "",
+            fileId: file2.id,
+            fileName: file2.name,
+            metadata: { deletedFromStorage: options?.deleteFromStorage ?? false }
+          })
+        )
+      );
+    }
   }
   // ============================================================================
   // LIST
@@ -15127,11 +15550,14 @@ var FileService = class extends BaseService {
    * @param userId - User ID to check
    * @returns true if user can access the file
    */
-  async checkAccess(fileId, userId) {
+  async checkAccess(fileId, userId, options) {
     const file2 = await this.getFile(fileId);
     if (!file2) {
       return false;
     }
+    if (options?.isAdmin) {
+      return true;
+    }
     if (file2.visibility === "public") {
       return true;
     }
@@ -15222,9 +15648,19 @@ var FileService = class extends BaseService {
 };
 
 // src/runtime/services/geocoding.service.ts
+var GEOCODING_TIMEOUT_MS = 5e3;
+function withTimeout(promise, ms, label) {
+  return Promise.race([
+    promise,
+    new Promise(
+      (_resolve, reject) => setTimeout(() => reject(new Error(`Geocoding ${label} timed out after ${ms}ms`)), ms)
+    )
+  ]);
+}
 var GeocodingService = class {
-  constructor(adapter) {
+  constructor(adapter, options) {
     this.adapter = adapter;
+    this.timeoutMs = options?.timeoutMs ?? GEOCODING_TIMEOUT_MS;
   }
   /**
    * Search for address suggestions as the user types
@@ -15233,11 +15669,15 @@ var GeocodingService = class {
     if (!params.query || params.query.trim().length < 2) {
       return [];
     }
-    return await this.adapter.autocomplete({
-      ...params,
-      query: params.query.trim(),
-      limit: params.limit ?? 5
-    });
+    return await withTimeout(
+      this.adapter.autocomplete({
+        ...params,
+        query: params.query.trim(),
+        limit: params.limit ?? 5
+      }),
+      this.timeoutMs,
+      "autocomplete"
+    );
   }
   /**
    * Reverse geocode coordinates to an address
@@ -15246,7 +15686,7 @@ var GeocodingService = class {
     if (!this.adapter.reverse) {
       throw new Error("Reverse geocoding is not supported by the configured adapter");
     }
-    return await this.adapter.reverse(params);
+    return await withTimeout(this.adapter.reverse(params), this.timeoutMs, "reverse");
   }
   /**
    * Geocode a structured address to coordinates
@@ -15255,7 +15695,7 @@ var GeocodingService = class {
     if (!this.adapter.geocode) {
       throw new Error("Geocoding is not supported by the configured adapter");
     }
-    return await this.adapter.geocode(params);
+    return await withTimeout(this.adapter.geocode(params), this.timeoutMs, "geocode");
   }
 };
 
@@ -15318,10 +15758,12 @@ var GlobalSearchService = class extends BaseService {
    * @returns Results grouped by object name
    */
   async searchGrouped(query, options) {
+    const limitPerGroup = options?.limitPerGroup ?? 5;
+    const estimatedGroupCount = 10;
+    const fetchLimit = Math.min(limitPerGroup * estimatedGroupCount, 100);
     const { results, total } = await this.search(query, {
       ...options,
-      limit: 100,
-      // Get more for grouping
+      limit: fetchLimit,
       offset: 0
     });
     const groupMap = /* @__PURE__ */ new Map();
@@ -15339,6 +15781,7 @@ var GlobalSearchService = class extends BaseService {
     }
     const groups = Array.from(groupMap.values()).map((g) => ({
       ...g,
+      results: g.results.slice(0, limitPerGroup),
       count: g.results.length
     }));
     groups.sort((a, b) => b.count - a.count);
@@ -15551,6 +15994,7 @@ var PermissionService = class extends BaseService {
   async updateRole(roleId, updates) {
     const oldRole = await this.permissionsRepo.getRoleById(roleId);
     const role = await this.permissionsRepo.updateRole(roleId, updates);
+    await this.invalidateAllCache();
     if (this.auditService && this.userId && oldRole) {
       const changes = [];
       if (updates.label !== void 0 && updates.label !== oldRole.label) {
@@ -15581,7 +16025,7 @@ var PermissionService = class extends BaseService {
   async deleteRole(roleId) {
     const role = await this.permissionsRepo.getRoleById(roleId);
     await this.permissionsRepo.deleteRole(roleId);
-    this.invalidateAllCache();
+    await this.invalidateAllCache();
     if (this.auditService && this.userId && role) {
       await this.auditService.logRoleAction({
         action: "role.deleted",
@@ -15605,7 +16049,7 @@ var PermissionService = class extends BaseService {
    */
   async setPermissions(roleId, permissions) {
     await this.permissionsRepo.setPermissions(roleId, permissions);
-    this.invalidateAllCache();
+    await this.invalidateAllCache();
     if (this.auditService && this.userId) {
       const role = await this.permissionsRepo.getRoleById(roleId);
       await this.auditService.logRoleAction({
@@ -15635,7 +16079,7 @@ var PermissionService = class extends BaseService {
       roleId,
       assignedBy
     });
-    this.invalidateCache(userProfileId);
+    await this.invalidateCache(userProfileId);
     if (this.auditService && this.userId) {
       const role = await this.permissionsRepo.getRoleById(roleId);
       await this.auditService.logRoleAction({
@@ -15654,7 +16098,7 @@ var PermissionService = class extends BaseService {
   async revokeRole(userProfileId, roleId) {
     const role = await this.permissionsRepo.getRoleById(roleId);
     await this.permissionsRepo.revokeRole(userProfileId, roleId);
-    this.invalidateCache(userProfileId);
+    await this.invalidateCache(userProfileId);
     if (this.auditService && this.userId) {
       await this.auditService.logRoleAction({
         action: "role.revoked",
@@ -15995,8 +16439,8 @@ async function syncNativeViews(adapter, nativeViewRegistry, options = {}) {
     errors: []
   };
   const nativeViews = nativeViewRegistry.getAll();
-  if (options.verbose) {
-    console.info(`[ViewSync] Starting sync for ${nativeViews.length} native views...`);
+  if (options.verbose && options.logger) {
+    options.logger.info(`[ViewSync] Starting sync for ${nativeViews.length} native views...`);
   }
   try {
     await adapter.transaction(async (tx) => {
@@ -16026,24 +16470,21 @@ function trackViewByObject(viewsByObject, nativeView) {
   objectViews.push(nativeView.name);
   viewsByObject.set(nativeView.object, objectViews);
 }
-function handleViewSyncError(result, nativeView, error2, options) {
+function handleViewSyncError(result, nativeView, error2, _options) {
   result.success = false;
   result.errors.push({
     viewName: nativeView.name,
     objectName: nativeView.object,
     error: error2 instanceof Error ? error2.message : String(error2)
   });
-  if (options.verbose) {
-    console.error(`[ViewSync] \u2717 Failed to sync ${nativeView.object}:${nativeView.name}:`, error2);
-  }
 }
 async function cleanupRemovedViews(tx, viewsByObject, result, options) {
   if (options.dryRun) return;
   for (const [objectName, viewNames] of viewsByObject) {
     const deletedCount = await tx.views.deleteNotIn(objectName, viewNames);
     result.viewsDeleted += deletedCount;
-    if (options.verbose && deletedCount > 0) {
-      console.info(`[ViewSync] Deleted ${deletedCount} obsolete views for ${objectName}`);
+    if (options.verbose && deletedCount > 0 && options.logger) {
+      options.logger.info(`[ViewSync] Deleted ${deletedCount} obsolete views for ${objectName}`);
     }
   }
 }
@@ -16056,8 +16497,8 @@ function handleTransactionError(result, error2) {
   });
 }
 function logSyncComplete(result, options) {
-  if (options.verbose) {
-    console.info(
+  if (options.verbose && options.logger) {
+    options.logger.info(
       `[ViewSync] ${result.success ? "\u2713" : "\u2717"} Sync complete:
   Views: ${result.viewsCreated} created, ${result.viewsUpdated} updated, ${result.viewsDeleted} deleted
   Errors: ${result.errors.length}`
@@ -16077,8 +16518,8 @@ async function syncSingleView(adapter, nativeView, result, options) {
   }
   result.viewsSynced++;
   if (options.dryRun) {
-    if (options.verbose) {
-      console.info(
+    if (options.verbose && options.logger) {
+      options.logger.info(
         `[ViewSync] Would ${isNew ? "create" : "update"} view: ${nativeView.object}:${nativeView.name}`
       );
     }
@@ -16095,8 +16536,8 @@ async function syncSingleView(adapter, nativeView, result, options) {
     system: true,
     metadata: nativeView.metadata
   });
-  if (options.verbose) {
-    console.info(
+  if (options.verbose && options.logger) {
+    options.logger.info(
       `[ViewSync] \u2713 Synced ${nativeView.object}:${nativeView.name}: ${nativeView.tabs.length} tabs`
     );
   }
@@ -16161,9 +16602,6 @@ async function syncNativeObjects(adapter, nativeRegistry, options = {}) {
             objectName: nativeObject.name,
             error: error2 instanceof Error ? error2.message : String(error2)
           });
-          if (options.verbose) {
-            console.error(`[SyncService] \u2717 Failed to sync ${nativeObject.name}:`, error2);
-          }
         }
       }
     });
@@ -16449,6 +16887,8 @@ export {
   ProtectedRoleError,
   RoleNotFoundError,
   isForbiddenError,
+  ConcurrentModificationError,
+  isConcurrentModificationError,
   text,
   textarea,
   richtext,
@@ -16640,8 +17080,6 @@ export {
   BaseService,
   BaseRepository,
   SchemaContextAwareRepository,
-  TenantAwareRepository,
-  TenantAwareService,
   buildAuditChanges,
   ObjectSchemaService,
   AuditService,