@stndrds/schema 0.1.0-alpha.50 → 0.1.0-alpha.52

package/dist/{chunk-FDWX5X6L.mjs → chunk-D4AFKFAX.mjs}

@@ -3152,6 +3152,10 @@ function createMockFilesRepository(stores) {
       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 = {
@@ -4123,6 +4127,284 @@ function createMockWorkflowParticipationsRepository(stores) {
     }
   };
 }
+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);
+    }
+  };
+}
+function createMockAIUserMemoryRepository(stores) {
+  const getKey = () => {
+    const tenantId = getTenantId();
+    const userId = requireUserId();
+    return `${tenantId}:${userId}`;
+  };
+  return {
+    get() {
+      const key = getKey();
+      return Promise.resolve(stores.aiUserMemory.get(key) ?? null);
+    },
+    upsert(data) {
+      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: data.preferences ?? existing?.preferences ?? {},
+        facts: data.facts ?? existing?.facts ?? [],
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      stores.aiUserMemory.set(key, memory);
+      return Promise.resolve(memory);
+    },
+    addFact(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 ?? [], fact],
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now
+      };
+      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);
+    }
+  };
+}
 function createMockAdapter() {
   const stores = {
     objects: /* @__PURE__ */ new Map(),
@@ -4136,7 +4418,12 @@ function createMockAdapter() {
     userRoles: /* @__PURE__ */ new Map(),
     workflows: /* @__PURE__ */ new Map(),
     workflowInstances: /* @__PURE__ */ new Map(),
-    workflowParticipations: /* @__PURE__ */ new Map()
+    workflowParticipations: /* @__PURE__ */ new Map(),
+    // AI stores
+    aiConversations: /* @__PURE__ */ new Map(),
+    aiMessages: /* @__PURE__ */ new Map(),
+    aiUserMemory: /* @__PURE__ */ new Map(),
+    aiUsageMetrics: /* @__PURE__ */ new Map()
   };
   const adapter = {
     objects: createMockObjectsRepository(stores),
@@ -4149,6 +4436,10 @@ function createMockAdapter() {
     workflows: createMockWorkflowsRepository(stores),
     workflowInstances: createMockWorkflowInstancesRepository(stores),
     workflowParticipations: createMockWorkflowParticipationsRepository(stores),
+    // AI repositories
+    aiConversations: createMockAIConversationsRepository(stores),
+    aiUserMemory: createMockAIUserMemoryRepository(stores),
+    aiUsageMetrics: createMockAIUsageMetricsRepository(stores),
     async transaction(callback) {
       return await callback(adapter);
     },
@@ -4168,6 +4459,10 @@ function createMockAdapter() {
       stores.workflows.clear();
       stores.workflowInstances.clear();
       stores.workflowParticipations.clear();
+      stores.aiConversations.clear();
+      stores.aiMessages.clear();
+      stores.aiUserMemory.clear();
+      stores.aiUsageMetrics.clear();
     }
   };
   return adapter;
@@ -9301,12 +9596,105 @@ var RecordQueryService = class extends BaseService {
   }
 };
 
+// src/runtime/services/record/record-resolver.service.ts
+var RecordResolverService = class extends BaseService {
+  constructor(adapter) {
+    super(adapter);
+  }
+  // ============================================================================
+  // CACHED RECORD ACCESS
+  // ============================================================================
+  /**
+   * Find a record by ID with caching.
+   *
+   * Uses the shared record cache for optimal performance.
+   * Delegates to findByIds for consistent cache handling.
+   *
+   * @param id - Record ID
+   * @returns Record or null if not found
+   */
+  async findById(id) {
+    if (!id) return null;
+    const results = await this.findByIds([id]);
+    return results[0] ?? null;
+  }
+  /**
+   * Find multiple records by IDs with caching.
+   *
+   * Each record is cached individually for reuse across services.
+   * Only fetches records not already in cache.
+   *
+   * @param ids - Record IDs to fetch
+   * @returns Array of found records (missing IDs are not included)
+   */
+  async findByIds(ids) {
+    if (!ids || ids.length === 0) {
+      return [];
+    }
+    const uniqueIds = [...new Set(ids)];
+    return this.cachedByMany(
+      "record",
+      uniqueIds,
+      (missingIds) => this.adapter.objectRecords.findByIds(missingIds),
+      (record) => record.id,
+      cacheTtl.records
+    );
+  }
+  // ============================================================================
+  // FACTORY METHODS
+  // ============================================================================
+  /**
+   * Create a RelationLabelResolver callback for computeLabelWithRelations.
+   *
+   * Used by RelationService.resolveLabel() and ObjectSchemaService.
+   *
+   * @returns Callback that resolves record IDs to their labels (cached)
+   */
+  createRelationLabelResolver() {
+    return async (ids) => {
+      const records = await this.findByIds(ids);
+      return new Map(records.map((r) => [r.id, r.label]));
+    };
+  }
+  /**
+   * Create a LabelResolver interface for label computation helpers.
+   *
+   * Used by RecordService for computing record labels.
+   *
+   * @param relationService - RelationService for resolving relation display labels
+   * @returns LabelResolver interface with cached record fetching
+   */
+  createLabelResolver(relationService) {
+    return {
+      resolveRelationIds: (ids, attrId) => relationService.resolveIds(ids, attrId),
+      findRecordLabels: (ids) => this.findByIds(ids)
+    };
+  }
+  /**
+   * Create a RollupCascadeContext for rollup recalculation.
+   *
+   * Used by RecordService after create/update/delete operations.
+   *
+   * @param rollupService - RollupService for recalculating rollups
+   * @param schemaService - ObjectSchemaService for fetching schemas
+   * @returns Context with cached record fetching
+   */
+  createRollupContext(rollupService, schemaService) {
+    return {
+      rollupService,
+      schemaService,
+      findRecordsByIds: (ids) => this.findByIds(ids)
+    };
+  }
+};
+
 // src/runtime/services/record/relation.service.ts
 var RelationService = class extends BaseService {
   constructor(adapter, nativeRegistry, options) {
     super(adapter);
     this.schemaService = new ObjectSchemaService(adapter, nativeRegistry);
-    this.queryService = options?.queryService;
+    this.queryService = options.queryService;
+    this.recordResolver = options.recordResolver;
   }
   /**
    * Set the query service after construction.
@@ -9384,7 +9772,7 @@ var RelationService = class extends BaseService {
       });
       return errors;
     }
-    const records = await this.adapter.objectRecords.findByIds(ids);
+    const records = await this.recordResolver.findByIds(ids);
     const recordMap = new Map(records.map((r) => [r.id, r]));
     const invalidIds = [];
     for (const id of ids) {
@@ -9506,20 +9894,7 @@ var RelationService = class extends BaseService {
       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) {
-        let label;
-        if (target.displayTemplate) {
-          label = await computeLabelWithRelations(
-            target.displayTemplate,
-            record.values,
-            objectSchema.attributes,
-            async (ids) => {
-              const linkedRecords = await this.adapter.objectRecords.findByIds(ids);
-              return new Map(linkedRecords.map((r) => [r.id, r.label]));
-            }
-          );
-        } else {
-          label = record.label;
-        }
+        const label = await this.resolveLabel(record, objectSchema, target.displayTemplate);
         allOptions.push({
           id: record.id,
           objectId: objectSchema.id,
@@ -9557,17 +9932,8 @@ var RelationService = class extends BaseService {
     if (!ids || ids.length === 0) {
       return [];
     }
-    const compositeIds = ids.map((id) => `${attributeId}:${id}`);
-    return this.cachedByMany(
-      "resolvedRelation",
-      compositeIds,
-      async (missingCompositeIds) => {
-        const missingRecordIds = missingCompositeIds.map((c) => c.split(":")[1]);
-        return this.fetchResolveIds(missingRecordIds, attributeId);
-      },
-      (item) => `${attributeId}:${item.id}`,
-      cacheTtl.resolvedRelations
-    );
+    const result = await this.resolveIdsBatch([{ attributeId, ids }]);
+    return result[attributeId] ?? [];
   }
   /**
    * Resolve multiple attribute/IDs batches in a single operation.
@@ -9610,7 +9976,7 @@ var RelationService = class extends BaseService {
     const allResolved = await this.cachedByMany(
       "resolvedRelation",
       allCompositeIds,
-      (missingCompositeIds) => this.fetchResolveIdsBatch(missingCompositeIds),
+      (missingCompositeIds) => this.resolveCompositeIds(missingCompositeIds),
       (item) => item._compositeId,
       cacheTtl.resolvedRelations
     );
@@ -9631,10 +9997,12 @@ var RelationService = class extends BaseService {
     return response;
   }
   /**
-   * Internal method to fetch and resolve multiple composite IDs at once.
+   * Internal method to resolve multiple composite IDs at once.
    * Optimized for batch operations - single DB query for all records.
+   *
+   * @param compositeIds - Array of composite IDs in format "attributeId:recordId"
    */
-  async fetchResolveIdsBatch(compositeIds) {
+  async resolveCompositeIds(compositeIds) {
     if (compositeIds.length === 0) {
       return [];
     }
@@ -9644,7 +10012,7 @@ var RelationService = class extends BaseService {
     });
     const uniqueRecordIds = [...new Set(parsed.map((p) => p.recordId))];
     const uniqueAttributeIds = [...new Set(parsed.map((p) => p.attributeId))];
-    const records = await this.adapter.objectRecords.findByIds(uniqueRecordIds);
+    const records = await this.recordResolver.findByIds(uniqueRecordIds);
     if (records.length === 0) {
       return [];
     }
@@ -9669,20 +10037,7 @@ var RelationService = class extends BaseService {
       const attribute = attributeMap.get(attributeId);
       const targetConfig = attribute?.targets?.find((t) => t.object === objectSchema.name);
       const customTemplate = targetConfig?.displayTemplate;
-      let label;
-      if (customTemplate) {
-        label = await computeLabelWithRelations(
-          customTemplate,
-          record.values,
-          objectSchema.attributes,
-          async (nestedIds) => {
-            const linkedRecords = await this.adapter.objectRecords.findByIds(nestedIds);
-            return new Map(linkedRecords.map((r) => [r.id, r.label]));
-          }
-        );
-      } else {
-        label = record.label;
-      }
+      const label = await this.resolveLabel(record, objectSchema, customTemplate);
       resolved.push({
         _compositeId: compositeId,
         id: record.id,
@@ -9696,59 +10051,22 @@ var RelationService = class extends BaseService {
     return resolved;
   }
   /**
-   * Internal method to fetch and resolve relation IDs (no caching).
-   * Uses batch fetching for performance - fetches all records in one query,
-   * then groups by objectId to minimize schema lookups.
+   * Resolve the display label for a record.
+   * Uses custom template if provided, otherwise falls back to pre-computed label.
    */
-  async fetchResolveIds(ids, attributeId) {
-    if (ids.length === 0) {
-      return [];
-    }
-    const attribute = await this.findAttributeById(attributeId);
-    const records = await this.adapter.objectRecords.findByIds(ids);
-    if (records.length === 0) {
-      return [];
-    }
-    const recordsByObjectId = /* @__PURE__ */ new Map();
-    for (const record of records) {
-      const existing = recordsByObjectId.get(record.objectId) ?? [];
-      existing.push(record);
-      recordsByObjectId.set(record.objectId, existing);
-    }
-    const resolved = [];
-    for (const [objectId, objectRecords] of recordsByObjectId) {
-      const objectSchema = await this.schemaService.getObjectSchema(objectId);
-      if (!objectSchema) {
-        continue;
-      }
-      const targetConfig = attribute?.targets?.find((t) => t.object === objectSchema.name);
-      const customTemplate = targetConfig?.displayTemplate;
-      for (const record of objectRecords) {
-        let label;
-        if (customTemplate) {
-          label = await computeLabelWithRelations(
-            customTemplate,
-            record.values,
-            objectSchema.attributes,
-            async (nestedIds) => {
-              const linkedRecords = await this.adapter.objectRecords.findByIds(nestedIds);
-              return new Map(linkedRecords.map((r) => [r.id, r.label]));
-            }
-          );
-        } else {
-          label = record.label;
+  async resolveLabel(record, objectSchema, customTemplate) {
+    if (customTemplate) {
+      return computeLabelWithRelations(
+        customTemplate,
+        record.values,
+        objectSchema.attributes,
+        async (nestedIds) => {
+          const linkedRecords = await this.recordResolver.findByIds(nestedIds);
+          return new Map(linkedRecords.map((r) => [r.id, r.label]));
         }
-        resolved.push({
-          id: record.id,
-          objectId: record.objectId,
-          objectName: objectSchema.name,
-          objectLabel: objectSchema.label,
-          objectIcon: objectSchema.icon,
-          label
-        });
-      }
+      );
     }
-    return resolved;
+    return record.label;
   }
   /**
    * Find a relation attribute by ID.
@@ -9779,8 +10097,9 @@ var RelationService = class extends BaseService {
 
 // src/runtime/services/record/rollup.service.ts
 var RollupService = class extends BaseService {
-  constructor(adapter) {
+  constructor(adapter, options) {
     super(adapter);
+    this.recordResolver = options.recordResolver;
   }
   /**
    * Calculate a rollup value for a record
@@ -9834,7 +10153,7 @@ var RollupService = class extends BaseService {
    * Example: entreprise222 has relation "entreprises" → companies, rollup collects from companies
    */
   async calculateForward(recordId, rollupAttr) {
-    const record = await this.adapter.objectRecords.findById(recordId);
+    const record = await this.recordResolver.findById(recordId);
     if (!record) {
       return { value: null, recordCount: 0 };
     }
@@ -9848,7 +10167,7 @@ var RollupService = class extends BaseService {
     if (relatedIds.length === 0) {
       return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
     }
-    const relatedRecords = await this.adapter.objectRecords.findByIds(relatedIds);
+    const relatedRecords = await this.recordResolver.findByIds(relatedIds);
     if (relatedRecords.length === 0) {
       return { value: this.getEmptyValue(rollupAttr.function), recordCount: 0 };
     }
@@ -9859,7 +10178,7 @@ var RollupService = class extends BaseService {
    * Example: Company has rollup on "orders", Order has relation "company" → companies
    */
   async calculateReverse(recordId, rollupAttr, schema) {
-    const record = await this.adapter.objectRecords.findById(recordId);
+    const record = await this.recordResolver.findById(recordId);
     if (!record) {
       return { value: null, recordCount: 0 };
     }
@@ -10166,25 +10485,25 @@ var RecordService = class extends BaseService {
     this.permissionService = options?.permissionService;
     this.auditService = options?.auditService ?? (adapter.audit ? new AuditService(adapter) : void 0);
     this.policyRegistry = options?.policyRegistry === null ? null : options?.policyRegistry ?? defaultPolicyRegistry;
+    this.recordResolver = new RecordResolverService(adapter);
     this.queryService = new RecordQueryService(adapter, this.schemaService, {
       permissionService: this.permissionService,
       policyRegistry: this.policyRegistry
     });
     this.relationService = new RelationService(adapter, registry, {
-      queryService: this.queryService
+      queryService: this.queryService,
+      recordResolver: this.recordResolver
+    });
+    this.rollupService = new RollupService(adapter, {
+      recordResolver: this.recordResolver
     });
     this.userService = new UserService(adapter);
-    this.rollupService = new RollupService(adapter);
     this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
-    this.labelResolver = {
-      resolveRelationIds: (ids, attrId) => this.relationService.resolveIds(ids, attrId),
-      findRecordLabels: (ids) => this.adapter.objectRecords.findByIds(ids)
-    };
-    this.rollupContext = {
-      rollupService: this.rollupService,
-      schemaService: this.schemaService,
-      findRecordsByIds: (ids) => this.adapter.objectRecords.findByIds(ids)
-    };
+    this.labelResolver = this.recordResolver.createLabelResolver(this.relationService);
+    this.rollupContext = this.recordResolver.createRollupContext(
+      this.rollupService,
+      this.schemaService
+    );
   }
   // ============================================================================
   // CREATE
@@ -10579,15 +10898,19 @@ var RecordService = class extends BaseService {
   }
 };
 
-// src/runtime/services/record/relation-resolver.service.ts
-var RelationResolverService = class {
-  constructor(adapter) {
-    this.adapter = adapter;
+// src/runtime/services/record/formula-resolver.service.ts
+var FormulaResolverService = class extends BaseService {
+  constructor(adapter, options) {
+    super(adapter);
+    this.recordResolver = options.recordResolver;
   }
+  // ============================================================================
+  // RESOLUTION
+  // ============================================================================
   /**
    * Resolve values from related records for formula evaluation
    *
-   * Phase 2: Supports 1 level of relation traversal only
+   * Supports 1 level of relation traversal only.
    *
    * @param record - The source record
    * @param schema - Schema of the source object
@@ -10596,7 +10919,6 @@ var RelationResolverService = class {
    *
    * @example
    * ```typescript
-   * // For an order with company relation
    * const resolved = await resolver.resolveRelationValues(
    *   orderRecord,
    *   orderSchema,
@@ -10625,7 +10947,7 @@ var RelationResolverService = class {
     if (idsToFetch.length === 0) {
       return result;
     }
-    const relatedRecords = await this.adapter.objectRecords.findByIds(idsToFetch);
+    const relatedRecords = await this.recordResolver.findByIds(idsToFetch);
     for (const relatedRecord of relatedRecords) {
       const attrName = attrIdMap.get(relatedRecord.id);
       if (attrName) {
@@ -10671,7 +10993,7 @@ var RelationResolverService = class {
     if (allIdsToFetch.size === 0) {
       return resultMap;
     }
-    const relatedRecords = await this.adapter.objectRecords.findByIds([...allIdsToFetch]);
+    const relatedRecords = await this.recordResolver.findByIds([...allIdsToFetch]);
     const relatedRecordMap = new Map(relatedRecords.map((r) => [r.id, r]));
     for (const record of records) {
       const result = resultMap.get(record.id);
@@ -10704,10 +11026,12 @@ var RelationResolverService = class {
     }
     return flat;
   }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
   /**
    * Extract a single relation ID from a value
    * Handles both single (string) and multi (array) relations
-   * @internal
    */
   extractSingleId(value) {
     if (typeof value === "string" && value.length > 0) {
@@ -10726,9 +11050,9 @@ var RollupScheduler = class {
     this.adapter = adapter;
     this.getSchemaById = getSchemaById;
     this.pending = /* @__PURE__ */ new Map();
-    this.rollupService = new RollupService(adapter);
-    this.debounceMs = options?.debounceMs ?? 100;
-    this.maxPending = options?.maxPending ?? 100;
+    this.rollupService = new RollupService(adapter, { recordResolver: options.recordResolver });
+    this.debounceMs = options.debounceMs ?? 100;
+    this.maxPending = options.maxPending ?? 100;
   }
   /**
    * Schedule a rollup recalculation for a parent record.
@@ -14163,10 +14487,11 @@ export {
   createContextForRestore,
   recalculateParentRollups,
   RecordQueryService,
+  RecordResolverService,
   RelationService,
   RollupService,
   RecordService,
-  RelationResolverService,
+  FormulaResolverService,
   RollupScheduler,
   WorkflowService,
   WorkflowInstanceService,