@stndrds/schema 0.1.0-alpha.51 → 0.1.0-alpha.53

package/dist/{chunk-EK56IQJ7.mjs → chunk-2EIZ6QXN.mjs}

@@ -473,7 +473,26 @@ var cacheKeys = {
   // Invalidation Patterns (global)
   // -------------------------------------------------------------------------
   /** All cache for a tenant (nuclear option) */
-  allForTenant: (tenantId) => `*:${tenantId}:*`
+  allForTenant: (tenantId) => `*:${tenantId}:*`,
+  // -------------------------------------------------------------------------
+  // Shared Resources - No tenant scoping
+  // -------------------------------------------------------------------------
+  /** Object schema for shared object (not tenant-scoped) */
+  sharedObjectSchema: (objectId) => `shared:schema:obj:${objectId}`,
+  /** Object schema for shared object by name */
+  sharedObjectSchemaByName: (name) => `shared:schema:name:${name}`,
+  /** Attributes for a shared object */
+  sharedObjectAttributes: (objectId) => `shared:attrs:${objectId}`,
+  /** Record from a shared object */
+  sharedRecord: (recordId) => `shared:record:${recordId}`,
+  /** Record list for a shared object */
+  sharedRecordList: (objectId, hash) => `shared:records:${objectId}:list:${hash}`,
+  /** All shared record lists for an object (for invalidation) */
+  allSharedRecordLists: (objectId) => `shared:records:${objectId}:list:*`,
+  /** All shared schemas (for invalidation) */
+  allSharedSchemas: () => "shared:schema:*",
+  /** All shared records (for invalidation) */
+  allSharedRecords: () => "shared:record:*"
 };
 var cacheTtl = {
   /** Object schemas - rarely change (1 hour) */
@@ -2885,6 +2904,7 @@ function createMockObjectsRepository(stores) {
         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()
@@ -2943,6 +2963,7 @@ function createMockObjectsRepository(stores) {
         icon: data.icon,
         labelExpression: data.labelExpression,
         system: data.system,
+        sharingMode: data.sharingMode,
         metadata: data.metadata,
         createdAt: /* @__PURE__ */ new Date(),
         updatedAt: /* @__PURE__ */ new Date()
@@ -5692,6 +5713,7 @@ function rollup(config) {
 import z2 from "zod";
 var ObjectBuilder = class {
   constructor(config) {
+    this._sharingMode = "private";
     this.validateName(config.name);
     this.obj = {
       name: config.name,
@@ -5730,6 +5752,29 @@ var ObjectBuilder = class {
     this.obj.system = true;
     return this;
   }
+  /**
+   * Mark this object as shared across all tenants.
+   *
+   * Shared objects are:
+   * - Readable by all tenants
+   * - Only writable by the owner tenant (tenant_id)
+   * - Only syncable by the master tenant (requires masterTenantId in config)
+   *
+   * Records belonging to a shared object inherit the sharing mode.
+   *
+   * @example
+   * ```typescript
+   * const PRODUCT_CATALOG = object({ name: "product-catalog", label: "Product Catalog" })
+   *   .shared()     // All tenants can read, only master can write
+   *   .system()
+   *   .labelExpression("{{ name }}")
+   *   .attribute(text({ name: "name", label: "Name" }).required());
+   * ```
+   */
+  shared() {
+    this._sharingMode = "shared";
+    return this;
+  }
   /**
    * Add an attribute to the object with type accumulation
    *
@@ -5810,7 +5855,8 @@ The labelExpression defines how records are displayed in lists and relations.
     return {
       ...this.obj,
       pluralLabel: this._pluralLabel,
-      labelExpression: this._labelExpression
+      labelExpression: this._labelExpression,
+      sharingMode: this._sharingMode
     };
   }
   /**
@@ -7543,17 +7589,8 @@ function createRollupValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
 function createTextAreaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
   return z5.string();
 }
-var blockNoteBlockSchema = z5.lazy(
-  () => z5.object({
-    id: z5.string().min(1, "Block must have an id"),
-    type: z5.string().min(1, "Block must have a type"),
-    props: z5.record(z5.string(), z5.union([z5.boolean(), z5.number(), z5.string()])),
-    content: z5.any().optional(),
-    children: z5.array(z5.any())
-  })
-);
 function createRichtextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.array(blockNoteBlockSchema, {
+  return z5.string({
     message: messages.invalidRichtext(attr)
   });
 }
@@ -8239,6 +8276,25 @@ Reserved names: ${RESERVED_ATTRIBUTE_NAMES.join(", ")}`
     const dbObjects = await this.adapter.objects.list();
     return Promise.all(dbObjects.map((dbObject) => this.buildObjectDefinition(dbObject)));
   }
+  /**
+   * Get object ownership info for write access checks.
+   *
+   * Used by RecordService to verify if the current tenant can write
+   * to a shared object's records.
+   *
+   * @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
+    };
+  }
   /**
    * Invalidate all schema-related cache for the current tenant.
    * Called automatically after schema mutations.
@@ -9228,6 +9284,15 @@ function checkRecordDeleteOrThrow(policy, record, context) {
     throw new PolicyViolationError(policy.objectName, "delete", record.id);
   }
 }
+function checkSharedObjectWriteAccess(objectName, sharingMode, objectOwnerTenantId, currentTenantId) {
+  if (sharingMode === "shared" && objectOwnerTenantId !== currentTenantId) {
+    throw new SchemaError(
+      `Cannot modify shared object "${objectName}". Shared objects are read-only for non-owner tenants.`,
+      SchemaErrorCode.FORBIDDEN,
+      { objectName, ownerTenantId: objectOwnerTenantId, currentTenantId }
+    );
+  }
+}
 
 // src/runtime/services/record/helpers/label.ts
 function extractRelationIds2(val) {
@@ -9596,12 +9661,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.
@@ -9679,7 +9837,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) {
@@ -9801,20 +9959,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,
@@ -9852,17 +9997,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.
@@ -9905,7 +10041,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
     );
@@ -9926,10 +10062,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 [];
     }
@@ -9939,7 +10077,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 [];
     }
@@ -9964,20 +10102,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,
@@ -9991,59 +10116,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.
@@ -10074,8 +10162,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
@@ -10129,7 +10218,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 };
     }
@@ -10143,7 +10232,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 };
     }
@@ -10154,7 +10243,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 };
     }
@@ -10461,25 +10550,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
@@ -10496,6 +10585,13 @@ var RecordService = class extends BaseService {
    */
   async createRecord(objectId, data, options) {
     const schema = await this.schemaService.getObjectSchema(objectId);
+    const ownerInfo = await this.schemaService.getObjectOwnerInfo(objectId);
+    checkSharedObjectWriteAccess(
+      schema.name,
+      ownerInfo.sharingMode,
+      ownerInfo.tenantId,
+      this.tenantId
+    );
     const dataWithDefaults = applyDefaultValues(schema, data);
     await checkPermission(this.permissionService, this.userId, schema.name, "create");
     const hookCtx = createContextForCreate(
@@ -10613,6 +10709,13 @@ var RecordService = class extends BaseService {
       throw new RecordNotFoundError(recordId);
     }
     const schema = await this.schemaService.getObjectSchema(existing.objectId);
+    const ownerInfo = await this.schemaService.getObjectOwnerInfo(existing.objectId);
+    checkSharedObjectWriteAccess(
+      schema.name,
+      ownerInfo.sharingMode,
+      ownerInfo.tenantId,
+      this.tenantId
+    );
     await checkPermission(this.permissionService, this.userId, schema.name, "update");
     const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
     if (policy && this.userId) {
@@ -10722,6 +10825,13 @@ var RecordService = class extends BaseService {
       throw new RecordNotFoundError(recordId);
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
+    const ownerInfo = await this.schemaService.getObjectOwnerInfo(record.objectId);
+    checkSharedObjectWriteAccess(
+      schema.name,
+      ownerInfo.sharingMode,
+      ownerInfo.tenantId,
+      this.tenantId
+    );
     await checkPermission(this.permissionService, this.userId, schema.name, "delete");
     const policy = getPolicy(this.policyRegistry, this.userId, schema.name);
     if (policy && this.userId) {
@@ -10793,6 +10903,13 @@ var RecordService = class extends BaseService {
       );
     }
     const schema = await this.schemaService.getObjectSchema(record.objectId);
+    const ownerInfo = await this.schemaService.getObjectOwnerInfo(record.objectId);
+    checkSharedObjectWriteAccess(
+      schema.name,
+      ownerInfo.sharingMode,
+      ownerInfo.tenantId,
+      this.tenantId
+    );
     await checkPermission(this.permissionService, this.userId, schema.name, "update");
     const hookCtx = createContextForRestore(schema, this.tenantId, record, options?.hookMetadata);
     if (!options?.skipHooks) {
@@ -10874,15 +10991,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
@@ -10891,7 +11012,6 @@ var RelationResolverService = class {
    *
    * @example
    * ```typescript
-   * // For an order with company relation
    * const resolved = await resolver.resolveRelationValues(
    *   orderRecord,
    *   orderSchema,
@@ -10920,7 +11040,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) {
@@ -10966,7 +11086,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);
@@ -10999,10 +11119,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) {
@@ -11021,9 +11143,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.
@@ -14014,6 +14136,18 @@ async function syncSingleObject(adapter, nativeObject, result, options) {
   if (!nativeObject.system) {
     throw new Error(`Object ${nativeObject.name} is not marked as system`);
   }
+  if (nativeObject.sharingMode === "shared") {
+    if (!options.masterTenantId) {
+      throw new Error(
+        `Cannot sync shared object "${nativeObject.name}": masterTenantId must be configured in tenant options`
+      );
+    }
+    if (options.tenantId && options.tenantId !== options.masterTenantId) {
+      throw new Error(
+        `Cannot sync shared object "${nativeObject.name}": only master tenant "${options.masterTenantId}" can sync shared objects (current: "${options.tenantId}")`
+      );
+    }
+  }
   const existingObject = await adapter.objects.findSystemByName(nativeObject.name);
   const isNew = !existingObject;
   updateObjectStats(result, isNew);
@@ -14058,6 +14192,7 @@ async function upsertObject(adapter, nativeObject, _options) {
     description: nativeObject.description,
     labelExpression: nativeObject.labelExpression,
     icon: nativeObject.icon,
+    sharingMode: nativeObject.sharingMode ?? "private",
     metadata: nativeObject.metadata
   });
 }
@@ -14449,6 +14584,7 @@ export {
   checkRecordAccess,
   checkRecordModifyOrThrow,
   checkRecordDeleteOrThrow,
+  checkSharedObjectWriteAccess,
   computeLabel,
   enrichWithFormulas,
   enrichRecordsWithFormulas,
@@ -14458,10 +14594,11 @@ export {
   createContextForRestore,
   recalculateParentRollups,
   RecordQueryService,
+  RecordResolverService,
   RelationService,
   RollupService,
   RecordService,
-  RelationResolverService,
+  FormulaResolverService,
   RollupScheduler,
   WorkflowService,
   WorkflowInstanceService,