@stndrds/schema 0.1.0-alpha.14

package/dist/chunk-CLOGNKDD.mjs

@@ -0,0 +1,4040 @@
+// src/utils.ts
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function generatePrefixedId(prefix) {
+  return `${prefix}_${generateId()}`;
+}
+
+// src/runtime/mock-adapter.ts
+function createMockObjectsRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.objects.get(id) ?? null);
+    },
+    findByName(tenantId, name) {
+      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 obj = {
+        id: generateId(),
+        tenantId: data.tenantId,
+        name: data.name,
+        label: data.label,
+        description: data.description,
+        icon: data.icon,
+        system: data.system ?? false,
+        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);
+      if (!existing) {
+        return Promise.reject(new Error(`Object ${id} not found`));
+      }
+      const updated = {
+        ...existing,
+        ...data,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objects.set(id, updated);
+      return Promise.resolve(updated);
+    },
+    delete(id) {
+      stores.objects.delete(id);
+      return Promise.resolve();
+    },
+    list(tenantId) {
+      const results = Array.from(stores.objects.values()).filter(
+        (obj) => obj.tenantId === tenantId
+      );
+      return Promise.resolve(results);
+    },
+    upsert(data) {
+      for (const obj of stores.objects.values()) {
+        if (obj.system && obj.name === data.name) {
+          const updated = {
+            ...obj,
+            label: data.label,
+            description: data.description,
+            icon: data.icon,
+            metadata: data.metadata,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          stores.objects.set(obj.id, updated);
+          return Promise.resolve(updated);
+        }
+      }
+      const newObj = {
+        id: generateId(),
+        tenantId: data.tenantId,
+        name: data.name,
+        label: data.label,
+        description: data.description,
+        icon: data.icon,
+        system: data.system,
+        metadata: data.metadata,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objects.set(newObj.id, newObj);
+      return Promise.resolve(newObj);
+    }
+  };
+}
+function createMockAttributesRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.attributes.get(id) ?? null);
+    },
+    findByObjectId(objectId) {
+      const results = Array.from(stores.attributes.values()).filter(
+        (attr) => attr.objectId === objectId
+      );
+      return Promise.resolve(results);
+    },
+    create(data) {
+      const attr = {
+        id: generateId(),
+        objectId: data.objectId,
+        name: data.name,
+        label: data.label,
+        type: data.type,
+        description: data.description,
+        icon: data.icon,
+        system: data.system ?? false,
+        required: data.required ?? false,
+        unique: data.unique ?? false,
+        order: data.order ?? 0,
+        hidden: data.hidden,
+        archived: data.archived,
+        deprecated: data.deprecated,
+        defaultValue: data.defaultValue,
+        config: data.config ?? {},
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.attributes.set(attr.id, attr);
+      return Promise.resolve(attr);
+    },
+    update(id, data) {
+      const existing = stores.attributes.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`Attribute ${id} not found`));
+      }
+      const updated = {
+        ...existing,
+        ...data,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.attributes.set(id, updated);
+      return Promise.resolve(updated);
+    },
+    delete(id) {
+      stores.attributes.delete(id);
+      return Promise.resolve();
+    },
+    deleteByNames(objectId, excludeNames) {
+      let count = 0;
+      for (const [id, attr] of stores.attributes.entries()) {
+        if (attr.objectId === objectId && !excludeNames.includes(attr.name)) {
+          stores.attributes.delete(id);
+          count++;
+        }
+      }
+      return Promise.resolve(count);
+    },
+    upsert(data) {
+      for (const attr of stores.attributes.values()) {
+        if (attr.objectId === data.objectId && attr.name === data.name) {
+          const updated = {
+            ...attr,
+            label: data.label ?? attr.label,
+            type: data.type ?? attr.type,
+            description: data.description ?? attr.description,
+            icon: data.icon ?? attr.icon,
+            system: data.system ?? attr.system,
+            required: data.required ?? attr.required,
+            unique: data.unique ?? attr.unique,
+            order: data.order ?? attr.order,
+            hidden: data.hidden ?? attr.hidden,
+            archived: data.archived ?? attr.archived,
+            deprecated: data.deprecated ?? attr.deprecated,
+            defaultValue: data.defaultValue ?? attr.defaultValue,
+            config: data.config ?? attr.config,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          stores.attributes.set(attr.id, updated);
+          return Promise.resolve(updated);
+        }
+      }
+      return this.create(data);
+    }
+  };
+}
+function createMockUserProfilesRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.userProfiles.get(id) ?? null);
+    },
+    findByAuthId(authId) {
+      for (const profile of stores.userProfiles.values()) {
+        if (profile.authId === authId) {
+          return Promise.resolve(profile);
+        }
+      }
+      return Promise.resolve(null);
+    },
+    findByEmail(tenantId, email) {
+      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 profile = {
+        id: generateId(),
+        tenantId: data.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(tenantId, options) {
+      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);
+    },
+    updateLastLogin(id) {
+      const profile = stores.userProfiles.get(id);
+      if (profile) {
+        profile.lastLoginAt = /* @__PURE__ */ new Date();
+        stores.userProfiles.set(id, profile);
+      }
+      return Promise.resolve();
+    }
+  };
+}
+function createMockFilesRepository(stores) {
+  return {
+    findById(id) {
+      const file2 = stores.files.get(id);
+      if (file2?.deletedAt) return Promise.resolve(null);
+      return Promise.resolve(file2 ?? null);
+    },
+    create(data) {
+      const file2 = {
+        id: generateId(),
+        tenantId: data.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(tenantId, options) {
+      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(tenantId, folderPath) {
+      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 createMockObjectRecordsRepository(stores) {
+  return {
+    findById(id) {
+      const internal = stores.objectRecords.get(id);
+      if (!internal) return Promise.resolve(null);
+      const { tenantId: _, ...record } = internal;
+      return Promise.resolve(record);
+    },
+    create(data) {
+      const internal = {
+        id: generateId(),
+        tenantId: data.tenantId,
+        objectId: data.objectId,
+        completionStatus: data.completionStatus,
+        values: data.data,
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objectRecords.set(internal.id, internal);
+      const { tenantId: _, ...record } = internal;
+      return Promise.resolve(record);
+    },
+    update(id, data) {
+      const existing = stores.objectRecords.get(id);
+      if (!existing) {
+        return Promise.reject(new Error(`ObjectRecord ${id} not found`));
+      }
+      const { __completionStatus, ...valueData } = data;
+      const updated = {
+        ...existing,
+        completionStatus: __completionStatus ?? existing.completionStatus,
+        values: { ...existing.values, ...valueData },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.objectRecords.set(id, updated);
+      const { tenantId: _, ...record } = updated;
+      return Promise.resolve(record);
+    },
+    delete(id) {
+      stores.objectRecords.delete(id);
+      return Promise.resolve();
+    },
+    list(tenantId, objectId, options) {
+      let results = Array.from(stores.objectRecords.values()).filter(
+        (r) => r.tenantId === tenantId && r.objectId === objectId
+      );
+      const total = results.length;
+      if (options?.limit) {
+        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
+      }
+      const records = results.map(({ tenantId: _, ...r }) => r);
+      return Promise.resolve({ records, total });
+    },
+    search(tenantId, objectId, query, options) {
+      const lowerQuery = query.toLowerCase();
+      let results = Array.from(stores.objectRecords.values()).filter((r) => {
+        if (r.tenantId !== tenantId || r.objectId !== objectId) return false;
+        return Object.values(r.values).some(
+          (val) => String(val).toLowerCase().includes(lowerQuery)
+        );
+      });
+      const total = results.length;
+      if (options?.limit) {
+        results = results.slice(options.offset ?? 0, (options.offset ?? 0) + options.limit);
+      }
+      const records = results.map(({ tenantId: _, ...r }) => r);
+      return Promise.resolve({ records, total });
+    }
+  };
+}
+function createMockViewsRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.views.get(id) ?? null);
+    },
+    findByName(tenantId, objectName, viewName) {
+      return Promise.resolve(
+        Array.from(stores.views.values()).find(
+          (v) => v.tenantId === tenantId && v.objectName === objectName && v.name === viewName
+        ) ?? null
+      );
+    },
+    findByObjectName(tenantId, objectName) {
+      return Promise.resolve(
+        Array.from(stores.views.values()).filter(
+          (v) => v.tenantId === tenantId && v.objectName === objectName
+        )
+      );
+    },
+    findAllForTenant(tenantId) {
+      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 id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const dbView = {
+        id,
+        tenantId: data.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.tenantId, 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);
+    }
+  };
+}
+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()
+  };
+  const adapter = {
+    objects: createMockObjectsRepository(stores),
+    attributes: createMockAttributesRepository(stores),
+    userProfiles: createMockUserProfilesRepository(stores),
+    files: createMockFilesRepository(stores),
+    objectRecords: createMockObjectRecordsRepository(stores),
+    views: createMockViewsRepository(stores),
+    async transaction(callback) {
+      return await callback(adapter);
+    },
+    // Expose stores for testing inspection
+    _stores: stores,
+    // Reset all stores (useful between tests)
+    reset() {
+      stores.objects.clear();
+      stores.attributes.clear();
+      stores.userProfiles.clear();
+      stores.files.clear();
+      stores.objectRecords.clear();
+      stores.views.clear();
+    }
+  };
+  return adapter;
+}
+
+// src/runtime/services/file.service.ts
+var FileService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Create a new file record (after upload to storage)
+   *
+   * @param data - File metadata
+   * @returns Created file record
+   *
+   * @example
+   * ```typescript
+   * const service = new FileService(adapter, "tenant-123");
+   *
+   * // After uploading to S3
+   * const file = await service.createFile({
+   *   tenantId: "tenant-123",
+   *   name: "contract-2025.pdf",
+   *   originalName: "Contract Acme Corp 2025.pdf",
+   *   mimeType: "application/pdf",
+   *   size: 2458624,
+   *   storageProvider: "s3",
+   *   storagePath: "tenants/123/files/2025/contract.pdf",
+   *   storageBucket: "my-app-files",
+   *   url: "https://cdn.example.com/files/file-123",
+   *   uploadedBy: "profile-456",
+   *   visibility: "private"
+   * });
+   * ```
+   */
+  async createFile(data) {
+    if (data.tenantId !== this.tenantId) {
+      throw new Error(
+        `Tenant mismatch: service initialized with "${this.tenantId}" but data has "${data.tenantId}"`
+      );
+    }
+    return await this.adapter.files.create(data);
+  }
+  /**
+   * Get file by ID
+   */
+  async getFile(fileId) {
+    const file2 = await this.adapter.files.findById(fileId);
+    if (file2?.deletedAt) {
+      return null;
+    }
+    return file2;
+  }
+  /**
+   * Get file by ID or throw
+   */
+  async getFileOrThrow(fileId) {
+    const file2 = await this.getFile(fileId);
+    if (!file2) {
+      throw new Error(`File with id "${fileId}" not found`);
+    }
+    return file2;
+  }
+  /**
+   * Update file metadata
+   *
+   * @param fileId - File UUID
+   * @param data - Data to update
+   * @returns Updated file
+   */
+  async updateFile(fileId, data) {
+    await this.getFileOrThrow(fileId);
+    return await this.adapter.files.update(fileId, data);
+  }
+  /**
+   * Delete file (soft delete)
+   *
+   * @param fileId - File UUID
+   * @param options - Delete options
+   */
+  async deleteFile(fileId, options) {
+    if (options?.checkOwnership && options.userId) {
+      const file2 = await this.getFileOrThrow(fileId);
+      if (file2.uploadedBy !== options.userId) {
+        throw new Error("You can only delete files you uploaded");
+      }
+    }
+    if (options?.hard) {
+      await this.adapter.files.hardDelete(fileId);
+    } else {
+      await this.adapter.files.delete(fileId);
+    }
+  }
+  /**
+   * List files for the tenant
+   */
+  async listFiles(options) {
+    return await this.adapter.files.list(this.tenantId, options);
+  }
+  /**
+   * List files by folder
+   */
+  async listFilesByFolder(folderPath) {
+    return await this.adapter.files.findByFolder(this.tenantId, folderPath);
+  }
+  /**
+   * List files uploaded by a specific user
+   */
+  async listFilesByUploader(uploadedBy) {
+    return await this.adapter.files.findByUploader(uploadedBy);
+  }
+  /**
+   * Change file visibility
+   *
+   * @param fileId - File UUID
+   * @param visibility - New visibility level
+   * @param allowedUsers - Users allowed to access (if restricted)
+   */
+  async changeVisibility(fileId, visibility, allowedUsers) {
+    const updateData = { visibility };
+    if (visibility === "restricted" && allowedUsers) {
+      updateData.allowedUsers = allowedUsers;
+    }
+    return await this.updateFile(fileId, updateData);
+  }
+  /**
+   * Grant access to a file for specific users
+   *
+   * @param fileId - File UUID
+   * @param userIds - User IDs to grant access
+   */
+  async grantAccess(fileId, userIds) {
+    const file2 = await this.getFileOrThrow(fileId);
+    const currentAllowed = file2.allowedUsers || [];
+    const newAllowed = [.../* @__PURE__ */ new Set([...currentAllowed, ...userIds])];
+    return await this.updateFile(fileId, {
+      visibility: "restricted",
+      allowedUsers: newAllowed
+    });
+  }
+  /**
+   * Revoke access to a file for specific users
+   *
+   * @param fileId - File UUID
+   * @param userIds - User IDs to revoke access
+   */
+  async revokeAccess(fileId, userIds) {
+    const file2 = await this.getFileOrThrow(fileId);
+    const currentAllowed = file2.allowedUsers || [];
+    const newAllowed = currentAllowed.filter((id) => !userIds.includes(id));
+    return await this.updateFile(fileId, {
+      allowedUsers: newAllowed
+    });
+  }
+  /**
+   * Check if user has access to a file
+   *
+   * @param fileId - File UUID
+   * @param userId - User ID to check
+   * @returns true if user can access the file
+   */
+  async canAccess(fileId, userId) {
+    const file2 = await this.getFile(fileId);
+    if (!file2) {
+      return false;
+    }
+    if (file2.visibility === "public") {
+      return true;
+    }
+    if (file2.uploadedBy === userId) {
+      return true;
+    }
+    if (file2.visibility === "restricted") {
+      return file2.allowedUsers?.includes(userId) ?? false;
+    }
+    return false;
+  }
+  /**
+   * Move file to different folder
+   */
+  async moveToFolder(fileId, newFolderPath) {
+    return await this.updateFile(fileId, { folderPath: newFolderPath });
+  }
+  /**
+   * Add tags to file
+   */
+  async addTags(fileId, tags) {
+    const file2 = await this.getFileOrThrow(fileId);
+    const currentTags = file2.tags || [];
+    const newTags = [.../* @__PURE__ */ new Set([...currentTags, ...tags])];
+    return await this.updateFile(fileId, { tags: newTags });
+  }
+  /**
+   * Remove tags from file
+   */
+  async removeTags(fileId, tags) {
+    const file2 = await this.getFileOrThrow(fileId);
+    const currentTags = file2.tags || [];
+    const newTags = currentTags.filter((tag) => !tags.includes(tag));
+    return await this.updateFile(fileId, { tags: newTags });
+  }
+};
+
+// src/runtime/services/geocoding.service.ts
+var GeocodingService = class {
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  /**
+   * Search for address suggestions as the user types
+   */
+  async autocomplete(params) {
+    if (!params.query || params.query.trim().length < 2) {
+      return [];
+    }
+    return await this.adapter.autocomplete({
+      ...params,
+      query: params.query.trim(),
+      limit: params.limit ?? 5
+    });
+  }
+  /**
+   * Reverse geocode coordinates to an address
+   */
+  async reverse(params) {
+    if (!this.adapter.reverse) {
+      throw new Error("Reverse geocoding is not supported by the configured adapter");
+    }
+    return await this.adapter.reverse(params);
+  }
+  /**
+   * Geocode a structured address to coordinates
+   */
+  async geocode(params) {
+    if (!this.adapter.geocode) {
+      throw new Error("Geocoding is not supported by the configured adapter");
+    }
+    return await this.adapter.geocode(params);
+  }
+};
+
+// src/builders/attribute-validators.ts
+import { ICONS } from "@andyoucreate/constants";
+var VALID_ICONS = new Set(ICONS);
+var ATTRIBUTE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var MAX_NAME_LENGTH = 63;
+var MAX_LABEL_LENGTH = 128;
+function validateAttributeName(name) {
+  if (!name || name.length === 0) {
+    throw new Error("[AttributeBuilder] Attribute name cannot be empty");
+  }
+  if (name.length > MAX_NAME_LENGTH) {
+    throw new Error(
+      `[AttributeBuilder] Attribute name is too long (max ${MAX_NAME_LENGTH} characters)`
+    );
+  }
+  if (!ATTRIBUTE_NAME_REGEX.test(name)) {
+    throw new Error(
+      "[AttributeBuilder] Invalid attribute name format.\nName must be a valid variable identifier:\n  \u2705 Valid: 'firstName', 'first_name', 'FirstName', 'FIRST_NAME'\n  \u274C Invalid: 'first-name', 'first name', '123name', 'first.name'"
+    );
+  }
+}
+function validateLabel(label) {
+  if (!label || label.length === 0) {
+    throw new Error("[AttributeBuilder] Attribute label cannot be empty");
+  }
+  if (label.length > MAX_LABEL_LENGTH) {
+    throw new Error(
+      `[AttributeBuilder] Attribute label is too long (max ${MAX_LABEL_LENGTH} characters)`
+    );
+  }
+}
+function validateIconName(icon, context) {
+  if (!VALID_ICONS.has(icon)) {
+    throw new Error(
+      `[AttributeBuilder] Invalid icon "${icon}" in ${context}.
+Icon must be one of the predefined icons from @andyoucreate/constants.`
+    );
+  }
+}
+function validateOptions(options, attributeName) {
+  if (options.length === 0) return;
+  const ids = /* @__PURE__ */ new Set();
+  const values = /* @__PURE__ */ new Set();
+  for (const option of options) {
+    if (!option.id?.trim()) {
+      throw new Error(
+        `[AttributeBuilder] Option in "${attributeName}" has an empty or missing id.`
+      );
+    }
+    if (!option.value?.trim()) {
+      throw new Error(
+        `[AttributeBuilder] Option "${option.id}" in "${attributeName}" has an empty or missing value.`
+      );
+    }
+    if (!option.label?.trim()) {
+      throw new Error(
+        `[AttributeBuilder] Option "${option.id}" in "${attributeName}" has an empty or missing label.`
+      );
+    }
+    if (ids.has(option.id)) {
+      throw new Error(
+        `[AttributeBuilder] Duplicate option id "${option.id}" in "${attributeName}".`
+      );
+    }
+    ids.add(option.id);
+    if (values.has(option.value)) {
+      throw new Error(
+        `[AttributeBuilder] Duplicate option value "${option.value}" in "${attributeName}".`
+      );
+    }
+    values.add(option.value);
+    if (option.icon) {
+      validateIconName(option.icon, `option "${option.id}" of "${attributeName}"`);
+    }
+  }
+}
+
+// src/builders/attribute-builders.ts
+var BaseAttributeBuilder = class {
+  constructor(type, name, label) {
+    validateAttributeName(name);
+    validateLabel(label);
+    this.attr = {
+      name,
+      label,
+      type,
+      required: false
+    };
+  }
+  setRequired(value) {
+    this.attr.required = value;
+  }
+  system() {
+    this.attr.system = true;
+    return this;
+  }
+  disabled() {
+    this.attr.disabled = true;
+    return this;
+  }
+  hidden() {
+    this.attr.hidden = true;
+    return this;
+  }
+  placeholder(value) {
+    this.attr.placeholder = value;
+    return this;
+  }
+  description(value) {
+    this.attr.description = value;
+    return this;
+  }
+  icon(value) {
+    validateIconName(value, `attribute "${this.attr.name}"`);
+    this.attr.icon = value;
+    return this;
+  }
+  order(value) {
+    this.attr.order = value;
+    return this;
+  }
+  defaultValue(value) {
+    this.attr.defaultValue = value;
+    return this;
+  }
+  metadata(value) {
+    this.attr.metadata = value;
+    return this;
+  }
+  build() {
+    return this.attr;
+  }
+};
+var TextAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("text", name, label);
+  }
+  minLength(value) {
+    this.attr.minLength = value;
+    return this;
+  }
+  maxLength(value) {
+    this.attr.maxLength = value;
+    return this;
+  }
+  pattern(value) {
+    this.attr.pattern = value;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+  /**
+   * Set email validation pattern
+   */
+  email() {
+    this.attr.pattern = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
+    return this;
+  }
+  /**
+   * Set URL validation pattern
+   */
+  url() {
+    this.attr.pattern = "^https?:\\/\\/[\\w\\-]+(\\.[\\w\\-]+)+[/#?]?.*$";
+    return this;
+  }
+  /**
+   * Set slug validation pattern
+   */
+  slug() {
+    this.attr.pattern = "^[a-z0-9]+(?:-[a-z0-9]+)*$";
+    return this;
+  }
+};
+function text(config) {
+  return new TextAttributeBuilder(config.name, config.label);
+}
+var TextAreaAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("textarea", name, label);
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function textarea(config) {
+  return new TextAreaAttributeBuilder(config.name, config.label);
+}
+var NumberAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("number", name, label);
+  }
+  min(value) {
+    this.attr.min = value;
+    return this;
+  }
+  max(value) {
+    this.attr.max = value;
+    return this;
+  }
+  integer() {
+    this.attr.unit = "integer";
+    this.attr.decimals = 0;
+    return this;
+  }
+  decimal(decimals = 2) {
+    this.attr.unit = "decimal";
+    this.attr.decimals = decimals;
+    return this;
+  }
+  percentage() {
+    this.attr.unit = "percentage";
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function number(config) {
+  return new NumberAttributeBuilder(config.name, config.label);
+}
+var CheckboxAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("checkbox", name, label);
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function checkbox(config) {
+  return new CheckboxAttributeBuilder(config.name, config.label);
+}
+var DateAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("date", name, label);
+  }
+  format(value) {
+    this.attr.dateFormat = value;
+    return this;
+  }
+  minDate(value) {
+    this.attr.minDate = value;
+    return this;
+  }
+  maxDate(value) {
+    this.attr.maxDate = value;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function date(config) {
+  return new DateAttributeBuilder(config.name, config.label);
+}
+var PhoneAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("phone", name, label);
+  }
+  defaultCountry(value) {
+    this.attr.defaultCountryCode = value;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function phone(config) {
+  return new PhoneAttributeBuilder(config.name, config.label);
+}
+var CurrencyAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("currency", name, label);
+  }
+  defaultCurrency(value) {
+    this.attr.defaultCurrency = value;
+    return this;
+  }
+  allowedCurrencies(value) {
+    this.attr.allowedCurrencies = value;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function currency(config) {
+  return new CurrencyAttributeBuilder(config.name, config.label);
+}
+var StatusAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("status", name, label);
+  }
+  /**
+   * Set all options at once (preserves literal types for values)
+   */
+  options(value) {
+    validateOptions(value, this.attr.name ?? "unknown");
+    this.attr.options = value;
+    return this;
+  }
+  option(config) {
+    if (!this.attr.options) {
+      this.attr.options = [];
+    }
+    const allOptions = [...this.attr.options, config];
+    validateOptions(allOptions, this.attr.name ?? "unknown");
+    this.attr.options.push(config);
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function status(config) {
+  return new StatusAttributeBuilder(config.name, config.label);
+}
+var SelectAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("select", name, label);
+  }
+  /**
+   * Set all options at once (preserves literal types for values)
+   */
+  options(value) {
+    validateOptions(value, this.attr.name ?? "unknown");
+    this.attr.options = value;
+    return this;
+  }
+  option(config) {
+    if (!this.attr.options) {
+      this.attr.options = [];
+    }
+    const allOptions = [...this.attr.options, config];
+    validateOptions(allOptions, this.attr.name ?? "unknown");
+    this.attr.options.push(config);
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function select(config) {
+  return new SelectAttributeBuilder(config.name, config.label);
+}
+var MultiselectAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("multiselect", name, label);
+  }
+  /**
+   * Set all options at once (preserves literal types for values)
+   */
+  options(value) {
+    validateOptions(value, this.attr.name ?? "unknown");
+    this.attr.options = value;
+    return this;
+  }
+  option(config) {
+    if (!this.attr.options) {
+      this.attr.options = [];
+    }
+    const allOptions = [...this.attr.options, config];
+    validateOptions(allOptions, this.attr.name ?? "unknown");
+    this.attr.options.push(config);
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function multiselect(config) {
+  return new MultiselectAttributeBuilder(config.name, config.label);
+}
+var LocationAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("location", name, label);
+  }
+  granularity(value) {
+    this.attr.granularity = value;
+    return this;
+  }
+  enableAutocomplete() {
+    this.attr.enableAutocomplete = true;
+    return this;
+  }
+  enableMap() {
+    this.attr.enableMap = true;
+    return this;
+  }
+  defaultCountry(value) {
+    this.attr.defaultCountry = value;
+    return this;
+  }
+  allowedCountries(value) {
+    this.attr.allowedCountries = value;
+    return this;
+  }
+  displayFormat(value) {
+    this.attr.displayFormat = value;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function location(config) {
+  return new LocationAttributeBuilder(config.name, config.label);
+}
+var TimestampAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("timestamp", name, label);
+  }
+  autoUpdate() {
+    this.attr.autoUpdate = true;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function timestamp(config) {
+  return new TimestampAttributeBuilder(config.name, config.label);
+}
+var FileAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("file", name, label);
+  }
+  maxFiles(value) {
+    this.attr.maxFiles = value;
+    return this;
+  }
+  maxSize(bytes) {
+    this.attr.maxSize = bytes;
+    return this;
+  }
+  allowedTypes(types) {
+    this.attr.allowedTypes = types;
+    return this;
+  }
+  verification(config) {
+    this.attr.verification = config;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function file(config) {
+  return new FileAttributeBuilder(config.name, config.label);
+}
+var UserAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("user", name, label);
+  }
+  allowedRoles(roles) {
+    this.attr.allowedRoles = roles;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function user(config) {
+  return new UserAttributeBuilder(config.name, config.label);
+}
+var SingleRelationAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("relation", name, label);
+    this.attr.cardinality = "one";
+    this.attr.targets = [];
+  }
+  /**
+   * Add a target object that can be linked
+   * @param objectName - Name of the object (e.g., "companies")
+   * @param options - Display template and filter options
+   */
+  to(objectName, options) {
+    const target = {
+      object: objectName,
+      ...options
+    };
+    this.attr.targets?.push(target);
+    return this;
+  }
+  /**
+   * Set the deletion strategy when target record is deleted
+   * @param strategy - "restrict" (default), "cascade", or "set_null"
+   */
+  onDelete(strategy) {
+    this.attr.onDelete = strategy;
+    return this;
+  }
+  /**
+   * Convert to a multi-relation (cardinality: "many")
+   */
+  many() {
+    const multiBuilder = new MultiRelationAttributeBuilder(
+      this.attr.name,
+      this.attr.label ?? "",
+      {
+        targets: this.attr.targets,
+        onDelete: this.attr.onDelete,
+        isRequired: this.attr.required
+      }
+    );
+    return multiBuilder;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+var MultiRelationAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label, initOptions) {
+    super("relation", name, label);
+    this.attr.cardinality = "many";
+    this.attr.targets = initOptions?.targets ?? [];
+    this.attr.defaultValue = [];
+    if (initOptions?.onDelete) {
+      this.attr.onDelete = initOptions.onDelete;
+    }
+    if (initOptions?.isRequired) {
+      this.setRequired(true);
+    }
+  }
+  /**
+   * Add a target object that can be linked
+   * @param objectName - Name of the object (e.g., "companies")
+   * @param options - Display template and filter options
+   */
+  to(objectName, options) {
+    const target = {
+      object: objectName,
+      ...options
+    };
+    this.attr.targets?.push(target);
+    return this;
+  }
+  /**
+   * Set the deletion strategy when target record is deleted
+   * @param strategy - "restrict" (default), "cascade", or "set_null"
+   */
+  onDelete(strategy) {
+    this.attr.onDelete = strategy;
+    return this;
+  }
+  /**
+   * Set minimum number of relations required
+   */
+  minItems(count) {
+    this.attr.minItems = count;
+    return this;
+  }
+  /**
+   * Set maximum number of relations allowed
+   */
+  maxItems(count) {
+    this.attr.maxItems = count;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function relation(config) {
+  return new SingleRelationAttributeBuilder(config.name, config.label);
+}
+var RatingAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("rating", name, label);
+  }
+  max(value) {
+    this.attr.max = value;
+    return this;
+  }
+  iconType(value) {
+    this.attr.iconType = value;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function rating(config) {
+  return new RatingAttributeBuilder(config.name, config.label);
+}
+
+// src/builders/object-builder.ts
+import z from "zod";
+var ObjectBuilder = class {
+  constructor(config) {
+    this.validateName(config.name);
+    this.obj = {
+      name: config.name,
+      label: config.label,
+      attributes: [],
+      system: false
+    };
+  }
+  /**
+   * Set object description
+   */
+  description(value) {
+    this.obj.description = value;
+    return this;
+  }
+  /**
+   * Set object icon
+   */
+  icon(value) {
+    this.obj.icon = value;
+    return this;
+  }
+  /**
+   * Mark as system/native object (defined in code, protected)
+   * System objects cannot be deleted/modified by clients
+   */
+  system() {
+    this.obj.system = true;
+    return this;
+  }
+  /**
+   * Add an attribute to the object with type accumulation
+   *
+   * The return type accumulates the attribute's name and value type
+   * into the TRecord generic, enabling full inference.
+   *
+   * @param attr - Attribute definition or builder (auto-builds if builder)
+   */
+  attribute(attr) {
+    if (!this.obj.attributes) {
+      this.obj.attributes = [];
+    }
+    const finalAttr = "build" in attr && typeof attr.build === "function" ? attr.build() : attr;
+    this.obj.attributes.push(finalAttr);
+    return this;
+  }
+  /**
+   * Add multiple attributes at once
+   * Note: For full type inference, prefer chaining .attribute() calls
+   */
+  attributes(attrs) {
+    if (!this.obj.attributes) {
+      this.obj.attributes = [];
+    }
+    const finalAttrs = attrs.map((attr) => "build" in attr ? attr.build() : attr);
+    this.obj.attributes.push(...finalAttrs);
+    return this;
+  }
+  /**
+   * Set metadata
+   */
+  metadata(value) {
+    this.obj.metadata = value;
+    return this;
+  }
+  /**
+   * Set the title attribute (the text attribute used to display the object's name)
+   * Must reference a text attribute that has been added to the object.
+   * If not set, the first text attribute becomes the title attribute.
+   *
+   * @param attributeName - The name of a text attribute
+   */
+  titleAttribute(attributeName) {
+    this._titleAttribute = attributeName;
+    return this;
+  }
+  /**
+   * Build the final ObjectDefinition
+   * @throws Error if required fields are missing or invalid
+   */
+  build() {
+    if (!this.obj.name) {
+      throw new Error("[ObjectBuilder] Missing required field: name");
+    }
+    if (!this.obj.label) {
+      throw new Error("[ObjectBuilder] Missing required field: label");
+    }
+    const textAttributes = (this.obj.attributes ?? []).filter((attr) => attr.type === "text");
+    if (textAttributes.length === 0) {
+      throw new Error(
+        `[ObjectBuilder] Object "${this.obj.name}" must have at least one text attribute.
+A text attribute is required to serve as the object's title/display name.
+  \u2705 Example: .attribute(text({ name: 'name', label: 'Name' }).required())`
+      );
+    }
+    const titleAttrName = this._titleAttribute ?? textAttributes[0].name;
+    const titleAttr = textAttributes.find((attr) => attr.name === titleAttrName);
+    if (!titleAttr) {
+      const availableTextAttrs = textAttributes.map((a) => `'${a.name}'`).join(", ");
+      throw new Error(
+        `[ObjectBuilder] titleAttribute "${titleAttrName}" must be a text attribute.
+  Available text attributes: ${availableTextAttrs}`
+      );
+    }
+    return {
+      ...this.obj,
+      titleAttribute: titleAttrName
+    };
+  }
+  /**
+   * Validate object name format
+   * Must be kebab-case (slug format), max 63 characters
+   * @internal
+   */
+  validateName(name) {
+    if (name === void 0) {
+      return;
+    }
+    const objectNameSchema = z.string().min(1, "Object name cannot be empty").max(63, "Object name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+      message: "Invalid object name format.\nName must be in kebab-case (slug format):\n  \u2705 Valid: 'products', 'user-profiles', 'order-items'\n  \u274C Invalid: 'Products', 'userProfiles', 'user_profiles'"
+    });
+    try {
+      objectNameSchema.parse(name);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(`[ObjectBuilder] ${error.errors[0].message}`);
+      }
+      throw error;
+    }
+  }
+};
+function object(config) {
+  return new ObjectBuilder(config);
+}
+
+// src/builders/view-builder.ts
+import { z as z2 } from "zod";
+var GroupBuilder = class {
+  constructor(id, label) {
+    this.data = { fields: [] };
+    this.data.id = id;
+    this.data.label = label;
+  }
+  /**
+   * Set group description
+   */
+  description(value) {
+    this.data.description = value;
+    return this;
+  }
+  /**
+   * Make group collapsible
+   * @param collapsed - Initial collapsed state (default: false)
+   */
+  collapsible(collapsed = false) {
+    this.data.collapsible = true;
+    this.data.collapsed = collapsed;
+    return this;
+  }
+  /**
+   * Set display order
+   */
+  order(value) {
+    this.data.order = value;
+    return this;
+  }
+  /**
+   * Add multiple fields with default options
+   * @example .fields("name", "email", "phone")
+   */
+  fields(...names) {
+    for (const name of names) {
+      this.data.fields?.push({ attribute: name });
+    }
+    return this;
+  }
+  /**
+   * Add a single field with options
+   * @example .field("name", { span: 8, readOnly: true })
+   */
+  field(attribute, options) {
+    this.data.fields?.push({ attribute, ...options });
+    return this;
+  }
+  /**
+   * Build the group definition
+   */
+  build() {
+    if (!this.data.id) {
+      throw new Error("[GroupBuilder] id is required");
+    }
+    if (!this.data.label) {
+      throw new Error("[GroupBuilder] label is required");
+    }
+    if (!this.data.fields || this.data.fields.length === 0) {
+      throw new Error("[GroupBuilder] At least one field is required");
+    }
+    return this.data;
+  }
+};
+var TableTabConfig = class {
+  /** @internal */
+  constructor(view2, base, relation2) {
+    this.view = view2;
+    this.tabData = { ...base, type: "table", relation: relation2, columns: [] };
+  }
+  /**
+   * Set columns to display
+   * @example .columns("firstName", "lastName", "email")
+   */
+  columns(...names) {
+    this.tabData.columns = names;
+    return this;
+  }
+  /**
+   * Allow creating new records
+   */
+  create() {
+    this.tabData.allowCreate = true;
+    return this;
+  }
+  /**
+   * Allow inline editing
+   */
+  edit() {
+    this.tabData.allowEdit = true;
+    return this;
+  }
+  /**
+   * Allow deleting records
+   */
+  delete() {
+    this.tabData.allowDelete = true;
+    return this;
+  }
+  /**
+   * Enable all CRUD operations (create, edit, delete)
+   */
+  crud() {
+    this.tabData.allowCreate = true;
+    this.tabData.allowEdit = true;
+    this.tabData.allowDelete = true;
+    return this;
+  }
+  /**
+   * Set default filters
+   */
+  filters(value) {
+    this.tabData.filters = value;
+    return this;
+  }
+  /**
+   * Set default sort
+   * @example .sort("lastName") or .sort("createdAt", "desc")
+   */
+  sort(field, order = "asc") {
+    this.tabData.sort = { field, order };
+    return this;
+  }
+  /**
+   * Continue building with a new tab
+   */
+  tab(name, label) {
+    this.finalize();
+    return new TabBuilder(this.view, name, label);
+  }
+  /**
+   * Finish this tab and return to ViewBuilder
+   */
+  done() {
+    this.finalize();
+    return this.view;
+  }
+  /**
+   * Build the final view definition
+   */
+  build() {
+    this.finalize();
+    return this.view.build();
+  }
+  finalize() {
+    if (!this.tabData.columns || this.tabData.columns.length === 0) {
+      throw new Error(`[TableTabConfig] columns() is required for tab "${this.tabData.name}"`);
+    }
+    this.view._addTab(this.tabData);
+  }
+};
+var CustomTabConfig = class {
+  /** @internal */
+  constructor(view2, base, component) {
+    this.view = view2;
+    this.tabData = { ...base, type: "custom", component };
+  }
+  /**
+   * Set props to pass to the component
+   */
+  props(value) {
+    this.tabData.props = value;
+    return this;
+  }
+  /**
+   * Continue building with a new tab
+   */
+  tab(name, label) {
+    this.view._addTab(this.tabData);
+    return new TabBuilder(this.view, name, label);
+  }
+  /**
+   * Finish this tab and return to ViewBuilder
+   */
+  done() {
+    this.view._addTab(this.tabData);
+    return this.view;
+  }
+  /**
+   * Build the final view definition
+   */
+  build() {
+    this.view._addTab(this.tabData);
+    return this.view.build();
+  }
+};
+var TabBuilder = class {
+  /** @internal */
+  constructor(view2, name, label) {
+    this.view = view2;
+    this.base = {
+      id: name,
+      name,
+      label
+    };
+  }
+  /**
+   * Set tab icon
+   */
+  icon(value) {
+    this.base.icon = value;
+    return this;
+  }
+  /**
+   * Set display order
+   */
+  order(value) {
+    this.base.order = value;
+    return this;
+  }
+  /**
+   * Mark as system tab (protected)
+   */
+  system() {
+    this.base.system = true;
+    return this;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // TYPE DISCRIMINATORS
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Create a form tab with groups
+   * @example .form(group("info", "Info").fields("name", "email"))
+   */
+  form(...groups) {
+    if (groups.length === 0) {
+      throw new Error(
+        `[TabBuilder] form() requires at least one group for tab "${this.base.name}"`
+      );
+    }
+    const tab = {
+      ...this.base,
+      type: "form",
+      groups: groups.map((g) => g instanceof GroupBuilder ? g.build() : g)
+    };
+    return this.view._addTab(tab);
+  }
+  /**
+   * Create a table tab for a relation
+   * @example .table("contacts").columns("name", "email").crud()
+   */
+  table(relation2) {
+    return new TableTabConfig(this.view, this.base, relation2);
+  }
+  /**
+   * Create a custom tab with a component
+   * @example .custom("AnalyticsWidget").props({ period: "12m" })
+   */
+  custom(component) {
+    return new CustomTabConfig(this.view, this.base, component);
+  }
+};
+var ViewBuilder = class {
+  constructor(name, label) {
+    this.data = { tabs: [] };
+    this.validated = false;
+    this.validateName(name);
+    this.data.name = name;
+    this.data.label = label;
+  }
+  /**
+   * Set view description
+   */
+  description(value) {
+    this.data.description = value;
+    return this;
+  }
+  /**
+   * Set view icon
+   */
+  icon(value) {
+    this.data.icon = value;
+    return this;
+  }
+  /**
+   * Associate view with an object
+   * @param objectName - Object name (kebab-case)
+   */
+  for(objectName) {
+    this.data.object = objectName;
+    return this;
+  }
+  /**
+   * Mark as default view for the object
+   */
+  default() {
+    this.data.default = true;
+    return this;
+  }
+  /**
+   * Mark as system view (protected, defined by developer)
+   */
+  system() {
+    this.data.system = true;
+    return this;
+  }
+  /**
+   * Set metadata
+   */
+  metadata(value) {
+    this.data.metadata = value;
+    return this;
+  }
+  /**
+   * Start building a new tab
+   */
+  tab(name, label) {
+    return new TabBuilder(this, name, label);
+  }
+  /**
+   * Add a pre-built tab
+   */
+  addTab(tab) {
+    this.data.tabs?.push(tab);
+    return this;
+  }
+  /**
+   * @internal Used by TabBuilder to add tabs
+   */
+  _addTab(tab) {
+    this.data.tabs?.push(tab);
+    return this;
+  }
+  /**
+   * Build the final view definition
+   */
+  build() {
+    if (!this.data.object) {
+      throw new Error("[ViewBuilder] for() is required - specify the target object");
+    }
+    if (!this.data.tabs || this.data.tabs.length === 0) {
+      throw new Error("[ViewBuilder] At least one tab is required");
+    }
+    const tabNames = /* @__PURE__ */ new Set();
+    for (const tab of this.data.tabs) {
+      if (tabNames.has(tab.name)) {
+        throw new Error(`[ViewBuilder] Duplicate tab name "${tab.name}"`);
+      }
+      tabNames.add(tab.name);
+    }
+    this.validated = true;
+    return this.data;
+  }
+  /**
+   * Validate view name format (kebab-case)
+   */
+  validateName(name) {
+    const viewNameSchema = z2.string().min(1, "View name cannot be empty").max(63, "View name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+      message: "Invalid view name format.\nName must be in kebab-case:\n  \u2705 Valid: 'detail', 'list-view', 'company-detail'\n  \u274C Invalid: 'Detail', 'listView', 'list_view'"
+    });
+    try {
+      viewNameSchema.parse(name);
+    } catch (error) {
+      if (error instanceof z2.ZodError) {
+        throw new Error(`[ViewBuilder] ${error.errors[0].message}`);
+      }
+      throw error;
+    }
+  }
+};
+function view(name, label) {
+  return new ViewBuilder(name, label);
+}
+function group(id, label) {
+  return new GroupBuilder(id, label);
+}
+
+// src/runtime/services/object-schema.service.ts
+var ObjectSchemaService = class {
+  constructor(adapter, nativeRegistry) {
+    this.adapter = adapter;
+    this.nativeRegistry = nativeRegistry;
+  }
+  /**
+   * Create a new custom object
+   * Validates name format and ensures system=false
+   *
+   * @param definition - Object definition (attributes can be raw definitions or builders)
+   * @param tenantId - Tenant ID owning the object
+   * @returns Created ObjectDefinition
+   */
+  async createCustomObject(definition, tenantId) {
+    const builder = object({
+      name: definition.name,
+      label: definition.label
+    });
+    if (definition.description) builder.description(definition.description);
+    if (definition.icon) builder.icon(definition.icon);
+    if (definition.metadata) builder.metadata(definition.metadata);
+    if (definition.attributes && definition.attributes.length > 0) {
+      builder.attributes(definition.attributes);
+    }
+    const objectDef = builder.build();
+    const existing = await this.adapter.objects.findByName(tenantId, objectDef.name);
+    if (existing) {
+      throw new Error(`Object with name "${objectDef.name}" already exists`);
+    }
+    const metadata = {
+      ...objectDef.metadata,
+      icon: objectDef.icon
+    };
+    const dbObject = await this.adapter.objects.create({
+      tenantId,
+      name: objectDef.name,
+      label: objectDef.label,
+      description: objectDef.description,
+      system: false,
+      // Always false for custom objects
+      metadata
+    });
+    const createdAttributes = [];
+    if (objectDef.attributes.length > 0) {
+      for (const attr of objectDef.attributes) {
+        const dbAttr = await this.adapter.attributes.create({
+          objectId: dbObject.id,
+          name: attr.name,
+          label: attr.label,
+          type: attr.type,
+          required: attr.required ?? false,
+          system: false,
+          // Always false for custom attributes
+          config: {
+            ...attr,
+            // Remove common fields stored in columns
+            id: void 0,
+            name: void 0,
+            label: void 0,
+            type: void 0,
+            required: void 0,
+            system: void 0
+          }
+        });
+        createdAttributes.push(this.convertDBAttributeToAttribute(dbAttr));
+      }
+    }
+    return {
+      ...objectDef,
+      id: dbObject.id,
+      attributes: createdAttributes,
+      system: false
+    };
+  }
+  /**
+   * Add a custom attribute to an existing object
+   * Can be used on both custom and native objects
+   * Attributes added via API are always custom (system=false)
+   *
+   * @param objectId - Object UUID from database
+   * @param attribute - Attribute definition
+   * @returns Created Attribute
+   */
+  async addAttributeToObject(objectId, attribute) {
+    this.validateAttributeName(attribute.name);
+    const dbObject = await this.adapter.objects.findById(objectId);
+    if (!dbObject) {
+      throw new Error(`Object with id "${objectId}" not found`);
+    }
+    const existingAttributes = await this.adapter.attributes.findByObjectId(objectId);
+    const duplicate = existingAttributes.find((attr) => attr.name === attribute.name);
+    if (duplicate) {
+      throw new Error(
+        `Attribute with name "${attribute.name}" already exists on object "${dbObject.name}"`
+      );
+    }
+    const dbAttr = await this.adapter.attributes.create({
+      objectId,
+      name: attribute.name,
+      label: attribute.label,
+      type: attribute.type,
+      required: attribute.required ?? false,
+      unique: attribute.unique ?? false,
+      system: false,
+      // Always false for attributes added via API
+      config: {
+        // Store all extra properties in config
+        ...attribute,
+        // Remove common fields stored in columns
+        name: void 0,
+        label: void 0,
+        type: void 0,
+        required: void 0,
+        unique: void 0,
+        system: void 0
+      }
+    });
+    return this.convertDBAttributeToAttribute(dbAttr);
+  }
+  /**
+   * Update an attribute
+   * Can only update custom attributes (system=false)
+   *
+   * @param attributeId - Attribute UUID
+   * @param updates - Partial attribute updates
+   * @returns Updated Attribute
+   */
+  async updateAttribute(attributeId, updates) {
+    const dbAttr = await this.adapter.attributes.findById(attributeId);
+    if (!dbAttr) {
+      throw new Error(`Attribute with id "${attributeId}" not found`);
+    }
+    if (dbAttr.system) {
+      throw new Error(
+        `Cannot modify system attribute "${dbAttr.name}". System attributes are protected.`
+      );
+    }
+    if (updates.name && updates.name !== dbAttr.name) {
+      throw new Error(
+        "Attribute name cannot be changed after creation. Create a new attribute instead."
+      );
+    }
+    if (updates.type && updates.type !== dbAttr.type) {
+      throw new Error(
+        "Attribute type cannot be changed after creation. Create a new attribute instead."
+      );
+    }
+    const updatedDbAttr = await this.adapter.attributes.update(attributeId, {
+      label: updates.label,
+      required: updates.required,
+      config: updates ? {
+        ...dbAttr.config,
+        ...updates,
+        // Remove common fields
+        name: void 0,
+        label: void 0,
+        type: void 0,
+        required: void 0,
+        unique: void 0,
+        system: void 0
+      } : dbAttr.config
+    });
+    return this.convertDBAttributeToAttribute(updatedDbAttr);
+  }
+  /**
+   * Delete an attribute
+   * Can only delete custom attributes (system=false)
+   *
+   * @param attributeId - Attribute UUID
+   */
+  async deleteAttribute(attributeId) {
+    const dbAttr = await this.adapter.attributes.findById(attributeId);
+    if (!dbAttr) {
+      throw new Error(`Attribute with id "${attributeId}" not found`);
+    }
+    if (dbAttr.system) {
+      throw new Error(
+        `Cannot delete system attribute "${dbAttr.name}". System attributes are protected.`
+      );
+    }
+    await this.adapter.attributes.delete(attributeId);
+  }
+  /**
+   * List attributes for an object
+   *
+   * @param objectId - Object UUID
+   * @param options - Filter options
+   * @returns List of attributes
+   */
+  async listAttributes(objectId, options) {
+    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
+    let filtered = dbAttributes;
+    if (options?.systemOnly) {
+      filtered = dbAttributes.filter((attr) => attr.system);
+    } else if (options?.customOnly) {
+      filtered = dbAttributes.filter((attr) => !attr.system);
+    }
+    return filtered.map((attr) => this.convertDBAttributeToAttribute(attr));
+  }
+  /**
+   * Validate attribute name format (variable identifier)
+   * @internal
+   */
+  validateAttributeName(name) {
+    const variableNameRegex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    if (!name || name.length === 0) {
+      throw new Error("Attribute name cannot be empty");
+    }
+    if (name.length > 63) {
+      throw new Error("Attribute name is too long (max 63 characters)");
+    }
+    if (!variableNameRegex.test(name)) {
+      throw new Error(
+        "Invalid attribute name format.\nName must be a valid variable identifier:\n  \u2705 Valid: 'firstName', 'first_name', 'FirstName', 'FIRST_NAME'\n  \u274C Invalid: 'first-name', 'first name', '123name', 'first.name'"
+      );
+    }
+  }
+  /**
+   * Get complete object schema (system + custom attributes)
+   * If object is native, merges registry definition with DB custom attributes
+   * If object is custom, returns DB definition only
+   *
+   * @param objectId - Object UUID from database
+   * @returns Complete ObjectDefinition with all attributes
+   *
+   * @example
+   * ```typescript
+   * const service = new ObjectSchemaService(adapter, registry);
+   * const productSchema = await service.getObjectSchema("obj-123");
+   *
+   * console.log(productSchema.attributes); // System + custom attributes
+   * ```
+   */
+  async getObjectSchema(objectId) {
+    const dbObject = await this.adapter.objects.findById(objectId);
+    if (!dbObject) {
+      throw new Error(`Object with id "${objectId}" not found`);
+    }
+    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
+    if (dbObject.system) {
+      return this.mergeNativeObject(dbObject, dbAttributes);
+    }
+    return this.convertDBObjectToDefinition(dbObject, dbAttributes);
+  }
+  /**
+   * Get object schema by name (for system/native objects)
+   * @deprecated Use getObjectSchemaByNameForTenant for custom objects support
+   */
+  async getObjectSchemaByName(name) {
+    const dbObject = await this.adapter.objects.findSystemByName(name);
+    if (!dbObject) {
+      throw new Error(`Native object "${name}" not found in database`);
+    }
+    const dbAttributes = await this.adapter.attributes.findByObjectId(dbObject.id);
+    return this.mergeNativeObject(dbObject, dbAttributes);
+  }
+  /**
+   * Get object schema by name for a tenant (supports both native and custom objects)
+   */
+  async getObjectSchemaByNameForTenant(name, tenantId) {
+    let dbObject = await this.adapter.objects.findByName(tenantId, name);
+    if (!dbObject) {
+      dbObject = await this.adapter.objects.findSystemByName(name);
+    }
+    if (!dbObject) {
+      throw new Error(`Object "${name}" not found`);
+    }
+    const dbAttributes = await this.adapter.attributes.findByObjectId(dbObject.id);
+    if (dbObject.system) {
+      return this.mergeNativeObject(dbObject, dbAttributes);
+    }
+    return this.convertDBObjectToDefinition(dbObject, dbAttributes);
+  }
+  /**
+   * List all object schemas for a tenant
+   */
+  async listObjectSchemas(tenantId) {
+    const dbObjects = await this.adapter.objects.list(tenantId);
+    const schemas = await Promise.all(
+      dbObjects.map(async (dbObject) => {
+        const dbAttributes = await this.adapter.attributes.findByObjectId(dbObject.id);
+        if (dbObject.system) {
+          return this.mergeNativeObject(dbObject, dbAttributes);
+        }
+        return this.convertDBObjectToDefinition(dbObject, dbAttributes);
+      })
+    );
+    return schemas;
+  }
+  /**
+   * Merge native object from registry with custom attributes from DB
+   * @internal
+   */
+  mergeNativeObject(dbObject, dbAttributes) {
+    const nativeObject = this.nativeRegistry.getByName(dbObject.name);
+    if (!nativeObject) {
+      throw new Error(
+        `Native object "${dbObject.name}" not found in registry. Make sure to register it before querying.`
+      );
+    }
+    const systemAttributesFromDB = dbAttributes.filter((attr) => attr.system);
+    const customAttributes = dbAttributes.filter((attr) => !attr.system);
+    const dbAttrByName = new Map(systemAttributesFromDB.map((attr) => [attr.name, attr]));
+    const systemAttrs = nativeObject.attributes.map((registryAttr) => {
+      const dbAttr = dbAttrByName.get(registryAttr.name);
+      if (dbAttr) {
+        return {
+          ...registryAttr,
+          id: dbAttr.id
+        };
+      }
+      return registryAttr;
+    });
+    const customAttrs = customAttributes.map(
+      (dbAttr) => this.convertDBAttributeToAttribute(dbAttr)
+    );
+    return {
+      ...nativeObject,
+      id: dbObject.id,
+      attributes: [
+        ...systemAttrs,
+        // System attributes from registry (with DB IDs if synced)
+        ...customAttrs
+        // Custom attributes from DB
+      ]
+    };
+  }
+  /**
+   * Convert DB object + attributes to ObjectDefinition
+   * @internal
+   */
+  convertDBObjectToDefinition(dbObject, dbAttributes) {
+    const attributes = dbAttributes.map(
+      (dbAttr) => this.convertDBAttributeToAttribute(dbAttr)
+    );
+    const titleAttribute = dbObject.metadata?.titleAttribute ?? attributes.find((attr) => attr.type === "text")?.name ?? attributes[0]?.name ?? "name";
+    return {
+      id: dbObject.id,
+      name: dbObject.name,
+      label: dbObject.label,
+      description: dbObject.description,
+      icon: dbObject.metadata?.icon,
+      titleAttribute,
+      attributes,
+      system: dbObject.system,
+      metadata: dbObject.metadata
+    };
+  }
+  /**
+   * 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/native/registry.ts
+var NativeObjectRegistryClass = class {
+  constructor() {
+    this.objects = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Register one or more native objects
+   * Auto-builds if ObjectBuilder is passed instead of ObjectDefinition
+   * @param objects - Single object/builder or array of objects/builders to register
+   * @returns this (for chaining)
+   * @throws Error if object is invalid or already registered
+   *
+   * @example
+   * ```typescript
+   * // No .build() needed - registry auto-builds!
+   * const PRODUCT = object({ id: "obj-product", name: "products", label: "Product" })
+   *   .system()
+   *   .attribute(text({ id: "attr-name", name: "name", label: "Name" }));
+   *
+   * registry.register(PRODUCT);  // ← Auto-builds here
+   *
+   * // Can still explicitly .build() if you want
+   * registry.register(PRODUCT.build());
+   *
+   * // Register multiple
+   * registry.register([PRODUCT, ORDER, CUSTOMER]);
+   * ```
+   */
+  register(objects) {
+    const objectsArray = Array.isArray(objects) ? objects : [objects];
+    for (const obj of objectsArray) {
+      const object2 = "build" in obj && typeof obj.build === "function" ? obj.build() : obj;
+      this.validateAndRegister(object2);
+    }
+    return this;
+  }
+  /**
+   * Validate and register a single object
+   * @internal
+   */
+  validateAndRegister(object2) {
+    if (!object2.system) {
+      throw new Error(
+        `[NativeObjectRegistry] Cannot register object "${object2.name}" (id: ${object2.id}): missing system flag.
+Native objects must have system=true. Did you forget to call .system() in your builder?`
+      );
+    }
+    if (this.objects.has(object2.name)) {
+      const existing = this.objects.get(object2.name);
+      throw new Error(
+        `[NativeObjectRegistry] Duplicate object name "${object2.name}":
+  - Existing: "${existing?.label}" (id: ${existing?.id})
+  - New: "${object2.label}" (id: ${object2.id})
+Please use unique names for each native object.`
+      );
+    }
+    this.objects.set(object2.name, object2);
+  }
+  /**
+   * Get a native object by its name
+   * @param name - The object name
+   * @returns The object definition or undefined if not found
+   *
+   * @example
+   * ```typescript
+   * const product = registry.getByName("products");
+   * if (product) {
+   *   console.log(product.label); // "Product"
+   * }
+   * ```
+   */
+  getByName(name) {
+    return this.objects.get(name);
+  }
+  /**
+   * Get a native object or throw if not found
+   * @param name - The object name
+   * @returns The object definition
+   * @throws Error if not found
+   */
+  getByNameOrThrow(name) {
+    const object2 = this.objects.get(name);
+    if (!object2) {
+      throw new Error(
+        `[NativeObjectRegistry] Native object "${name}" not found.
+Available objects: ${this.listNames().join(", ")}`
+      );
+    }
+    return object2;
+  }
+  /**
+   * Get all registered native objects
+   * @returns Array of all registered object definitions
+   */
+  getAll() {
+    return Array.from(this.objects.values());
+  }
+  /**
+   * Get all registered native object names
+   * @returns Array of object names
+   */
+  listNames() {
+    return Array.from(this.objects.keys());
+  }
+  /**
+   * Check if a native object is registered
+   * @param name - The object name
+   * @returns true if registered, false otherwise
+   */
+  has(name) {
+    return this.objects.has(name);
+  }
+  /**
+   * Get the number of registered objects
+   */
+  get size() {
+    return this.objects.size;
+  }
+  /**
+   * Clear all registered objects (useful for testing)
+   * @internal
+   */
+  clear() {
+    this.objects.clear();
+  }
+  /**
+   * Get registry summary for debugging
+   */
+  summary() {
+    const objects = this.getAll();
+    return [
+      `[NativeObjectRegistry] ${this.size} native object(s) registered:`,
+      ...objects.map(
+        (obj) => `  - ${obj.name}: "${obj.label}" (${obj.attributes.length} attributes)`
+      )
+    ].join("\n");
+  }
+  /**
+   * Log registry summary to console
+   */
+  debug() {
+    console.info(this.summary());
+  }
+};
+var registry = new NativeObjectRegistryClass();
+
+// src/validation/validators.ts
+import { z as z3 } from "zod";
+function createTextValidator(attr) {
+  let schema = z3.string();
+  if (attr.minLength !== void 0) {
+    schema = schema.min(
+      attr.minLength,
+      `${attr.label} must be at least ${attr.minLength} characters`
+    );
+  }
+  if (attr.maxLength !== void 0) {
+    schema = schema.max(
+      attr.maxLength,
+      `${attr.label} must be at most ${attr.maxLength} characters`
+    );
+  }
+  if (attr.pattern) {
+    schema = schema.regex(new RegExp(attr.pattern), `${attr.label} format is invalid`);
+  }
+  return schema;
+}
+function createNumberValidator(attr) {
+  let schema = z3.number();
+  if (attr.min !== void 0) {
+    schema = schema.min(attr.min, `${attr.label} must be at least ${attr.min}`);
+  }
+  if (attr.max !== void 0) {
+    schema = schema.max(attr.max, `${attr.label} must be at most ${attr.max}`);
+  }
+  if (attr.unit === "integer") {
+    schema = schema.int(`${attr.label} must be an integer`);
+  }
+  return schema;
+}
+function createCheckboxValidator(_attr) {
+  return z3.boolean();
+}
+function createDateValidator(attr) {
+  return z3.string().datetime({ message: `${attr.label} must be a valid ISO date` });
+}
+function createPhoneValidator(_attr) {
+  return z3.object({
+    countryCode: z3.string().length(3),
+    phoneNumber: z3.string().min(1)
+  });
+}
+function createCurrencyValidator(_attr) {
+  return z3.object({
+    code: z3.string().length(3),
+    value: z3.number().min(0)
+  });
+}
+function createStatusValidator(attr) {
+  const validValues = attr.options.map((opt) => opt.value);
+  return z3.enum(validValues, {
+    errorMap: () => ({
+      message: `${attr.label} must be one of: ${validValues.join(", ")}`
+    })
+  });
+}
+function createSelectValidator(attr) {
+  const validValues = attr.options.map((opt) => opt.value);
+  return z3.enum(validValues, {
+    errorMap: () => ({
+      message: `${attr.label} must be one of: ${validValues.join(", ")}`
+    })
+  });
+}
+function createMultiselectValidator(attr) {
+  const validValues = attr.options.map((opt) => opt.value);
+  return z3.array(
+    z3.enum(validValues, {
+      errorMap: () => ({
+        message: `Each value must be one of: ${validValues.join(", ")}`
+      })
+    })
+  );
+}
+function createLocationValidator(_attr) {
+  return z3.object({
+    address: z3.string().optional(),
+    address2: z3.string().optional(),
+    city: z3.string().optional(),
+    state: z3.string().optional(),
+    postalCode: z3.string().optional(),
+    country: z3.string().length(3).optional(),
+    latitude: z3.number().optional(),
+    longitude: z3.number().optional()
+  });
+}
+function createTimestampValidator(_attr) {
+  return z3.number().int().positive();
+}
+function createFileValidator(_attr) {
+  return z3.string().uuid();
+}
+function createUserValidator(_attr) {
+  return z3.string().uuid();
+}
+function createSingleRelationValidator(attr) {
+  const uuidSchema = z3.string().uuid({
+    message: `${attr.label} must be a valid record ID`
+  });
+  return z3.union([uuidSchema, z3.null()]);
+}
+function createMultiRelationValidator(attr) {
+  const uuidSchema = z3.string().uuid({
+    message: `Each ${attr.label} item must be a valid record ID`
+  });
+  let arraySchema = z3.array(uuidSchema);
+  if (attr.minItems !== void 0) {
+    arraySchema = arraySchema.min(
+      attr.minItems,
+      `${attr.label} must have at least ${attr.minItems} item${attr.minItems > 1 ? "s" : ""}`
+    );
+  }
+  if (attr.maxItems !== void 0) {
+    arraySchema = arraySchema.max(
+      attr.maxItems,
+      `${attr.label} must have at most ${attr.maxItems} item${attr.maxItems > 1 ? "s" : ""}`
+    );
+  }
+  return arraySchema;
+}
+function createRelationValidator(attr) {
+  if (attr.cardinality === "many") {
+    return createMultiRelationValidator(attr);
+  }
+  return createSingleRelationValidator(attr);
+}
+function createRatingValidator(attr) {
+  let schema = z3.number().int().min(0);
+  if (attr.max !== void 0) {
+    schema = schema.max(attr.max, `${attr.label} must be at most ${attr.max}`);
+  }
+  return schema;
+}
+function createAttributeValidator(attr) {
+  switch (attr.type) {
+    case "text":
+      return createTextValidator(attr);
+    case "number":
+      return createNumberValidator(attr);
+    case "checkbox":
+      return createCheckboxValidator(attr);
+    case "date":
+      return createDateValidator(attr);
+    case "phone":
+      return createPhoneValidator(attr);
+    case "currency":
+      return createCurrencyValidator(attr);
+    case "status":
+      return createStatusValidator(attr);
+    case "location":
+      return createLocationValidator(attr);
+    case "timestamp":
+      return createTimestampValidator(attr);
+    case "select":
+      return createSelectValidator(attr);
+    case "multiselect":
+      return createMultiselectValidator(attr);
+    case "file":
+      return createFileValidator(attr);
+    case "user":
+      return createUserValidator(attr);
+    case "relation":
+      return createRelationValidator(attr);
+    case "rating":
+      return createRatingValidator(attr);
+    default:
+      return z3.unknown();
+  }
+}
+function createObjectValidator(objectDef) {
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    let validator = createAttributeValidator(attr);
+    if (!attr.required) {
+      validator = validator.optional();
+    }
+    shape[attr.name] = validator;
+  }
+  return z3.object(shape);
+}
+function validateAttribute(attr, value) {
+  const validator = createAttributeValidator(attr);
+  if (!attr.required && (value === void 0 || value === null)) {
+    return { success: true, data: { [attr.name]: value } };
+  }
+  const result = validator.safeParse(value);
+  if (result.success) {
+    return {
+      success: true,
+      data: { [attr.name]: result.data }
+    };
+  }
+  return {
+    success: false,
+    errors: result.error.errors.map((err) => ({
+      path: [attr.name, ...err.path.map(String)],
+      message: err.message
+    }))
+  };
+}
+function validateObject(objectDef, data) {
+  const validator = createObjectValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: result.error.errors.map((err) => ({
+      path: err.path.map(String),
+      message: err.message
+    }))
+  };
+}
+function validateObjectOrThrow(objectDef, data) {
+  const result = validateObject(objectDef, data);
+  if (!result.success) {
+    const errorMessages = result.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new Error(`Validation failed for ${objectDef.label}:
+${errorMessages}`);
+  }
+  return result.data;
+}
+function createDraftValidator(objectDef) {
+  const shape = {};
+  for (const attr of objectDef.attributes) {
+    const validator = createAttributeValidator(attr).optional();
+    shape[attr.name] = validator;
+  }
+  return z3.object(shape);
+}
+function validateDraft(objectDef, data) {
+  const validator = createDraftValidator(objectDef);
+  const result = validator.safeParse(data);
+  if (result.success) {
+    return {
+      success: true,
+      data: result.data
+    };
+  }
+  return {
+    success: false,
+    errors: result.error.errors.map((err) => ({
+      path: err.path.map(String),
+      message: err.message
+    }))
+  };
+}
+function validateDraftOrThrow(objectDef, data) {
+  const result = validateDraft(objectDef, data);
+  if (!result.success) {
+    const errorMessages = result.errors?.map((err) => `${err.path.join(".")}: ${err.message}`).join("\n") || "Unknown validation error";
+    throw new Error(`Draft validation failed for ${objectDef.label}:
+${errorMessages}`);
+  }
+  return result.data;
+}
+function isValuePresent(value) {
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (typeof value === "string" && value.trim() === "") {
+    return false;
+  }
+  return true;
+}
+function getMissingRequiredAttributes(objectDef, data) {
+  const missing = [];
+  for (const attr of objectDef.attributes) {
+    if (attr.required && !isValuePresent(data[attr.name])) {
+      missing.push(attr);
+    }
+  }
+  return missing;
+}
+function isRecordComplete(objectDef, data) {
+  const missing = getMissingRequiredAttributes(objectDef, data);
+  if (missing.length > 0) {
+    return false;
+  }
+  const validation = validateObject(objectDef, data);
+  return validation.success;
+}
+function computeRecordStatus(objectDef, data) {
+  return isRecordComplete(objectDef, data) ? "complete" : "draft";
+}
+
+// src/runtime/services/relation.service.ts
+var RelationService = class {
+  constructor(adapter, nativeRegistry) {
+    this.adapter = adapter;
+    this.schemaService = new ObjectSchemaService(adapter, nativeRegistry);
+  }
+  /**
+   * Validate all relation attributes in the data
+   *
+   * @param schema - Object schema containing attribute definitions
+   * @param data - Record data to validate
+   * @returns Validation result with errors if any
+   *
+   * @example
+   * ```typescript
+   * const result = await relationService.validateRelations(schema, {
+   *   company: "rec-123",
+   *   contacts: ["rec-456", "rec-789"]
+   * });
+   *
+   * if (!result.valid) {
+   *   console.log(result.errors);
+   *   // [{ attribute: "company", message: "Record not found", invalidIds: ["rec-123"] }]
+   * }
+   * ```
+   */
+  async validateRelations(schema, data) {
+    const errors = [];
+    const relationAttrs = schema.attributes.filter(
+      (attr) => attr.type === "relation"
+    );
+    for (const attr of relationAttrs) {
+      const value = data[attr.name];
+      if (value === void 0 || value === null) {
+        continue;
+      }
+      const attrErrors = await this.validateRelationAttribute(attr, value);
+      errors.push(...attrErrors);
+    }
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Validate a single relation attribute value
+   */
+  async validateRelationAttribute(attr, value) {
+    const errors = [];
+    const ids = this.extractIds(attr, value);
+    if (ids.length === 0) {
+      return errors;
+    }
+    const validObjectIds = await this.getValidObjectIds(attr.targets);
+    if (validObjectIds.size === 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `No valid target objects found for ${attr.label}`
+      });
+      return errors;
+    }
+    const invalidIds = [];
+    for (const id of ids) {
+      const record = await this.adapter.objectRecords.findById(id);
+      if (!record) {
+        invalidIds.push(id);
+        continue;
+      }
+      if (!validObjectIds.has(record.objectId)) {
+        invalidIds.push(id);
+      }
+    }
+    if (invalidIds.length > 0) {
+      errors.push({
+        attribute: attr.name,
+        message: `Invalid or non-existent records for ${attr.label}`,
+        invalidIds
+      });
+    }
+    return errors;
+  }
+  /**
+   * Extract IDs from relation value based on cardinality
+   */
+  extractIds(attr, value) {
+    if (attr.cardinality === "many") {
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.filter((v) => typeof v === "string");
+    }
+    if (typeof value === "string") {
+      return [value];
+    }
+    return [];
+  }
+  /**
+   * Get valid object IDs from relation targets
+   */
+  async getValidObjectIds(targets) {
+    const objectIds = /* @__PURE__ */ new Set();
+    for (const target of targets) {
+      try {
+        const objectSchema = await this.schemaService.getObjectSchemaByName(target.object);
+        if (objectSchema?.id) {
+          objectIds.add(objectSchema.id);
+        }
+      } catch {
+      }
+    }
+    return objectIds;
+  }
+  /**
+   * Validate relations and throw if invalid
+   */
+  async validateRelationsOrThrow(schema, data) {
+    const result = await this.validateRelations(schema, data);
+    if (!result.valid) {
+      const messages = result.errors.map((e) => `${e.attribute}: ${e.message}`).join("; ");
+      throw new Error(`Relation validation failed: ${messages}`);
+    }
+  }
+  // ============================================================================
+  // OPTIONS & RESOLUTION
+  // ============================================================================
+  /**
+   * Get available options for a relation attribute
+   * Searches across all target objects defined in the relation
+   *
+   * @param attribute - Relation attribute definition
+   * @param tenantId - Tenant ID for multi-tenant isolation
+   * @param params - Query parameters
+   *
+   * @example
+   * ```typescript
+   * const options = await relationService.getOptions(attribute, "tenant-1", {
+   *   query: "nike",
+   *   page: 1,
+   *   pageSize: 20
+   * });
+   * ```
+   */
+  async getOptions(attribute, tenantId, params = {}) {
+    const { query = "", page = 1, pageSize = 20, targetObject } = params;
+    const targets = attribute.targets;
+    const filteredTargets = targetObject ? targets.filter((t) => t.object === targetObject) : targets;
+    if (filteredTargets.length === 0) {
+      return { options: [], hasMore: false, total: 0 };
+    }
+    const allOptions = [];
+    let totalCount = 0;
+    const recordService = new RecordService(this.adapter, tenantId);
+    for (const target of filteredTargets) {
+      const objectSchema = await this.schemaService.getObjectSchemaByName(target.object);
+      if (!objectSchema?.id) {
+        continue;
+      }
+      const result = query ? await recordService.searchRecords(objectSchema.id, query, {
+        limit: pageSize,
+        offset: (page - 1) * pageSize
+      }) : await recordService.listRecords(objectSchema.id, {
+        limit: pageSize,
+        offset: (page - 1) * pageSize
+      });
+      totalCount += result.total;
+      for (const record of result.records) {
+        const label = this.resolveLabel(
+          record.values,
+          objectSchema.titleAttribute,
+          target.displayTemplate
+        );
+        allOptions.push({
+          id: record.id,
+          objectId: objectSchema.id,
+          objectName: objectSchema.name,
+          objectLabel: objectSchema.label,
+          objectIcon: objectSchema.icon,
+          label,
+          data: record.values
+        });
+      }
+    }
+    const hasMore = totalCount > page * pageSize;
+    return {
+      options: allOptions.slice(0, pageSize),
+      hasMore,
+      total: totalCount
+    };
+  }
+  /**
+   * Resolve record IDs to their display labels
+   * Useful for displaying current values in the UI
+   *
+   * @param ids - Record IDs to resolve
+   * @param tenantId - Tenant ID for multi-tenant isolation
+   *
+   * @example
+   * ```typescript
+   * const resolved = await relationService.resolveIds(["rec-1", "rec-2"], "tenant-1");
+   * // [{ id: "rec-1", label: "Nike Air Max", objectName: "products", ... }]
+   * ```
+   */
+  async resolveIds(ids, tenantId) {
+    if (!ids || ids.length === 0) {
+      return [];
+    }
+    const recordService = new RecordService(this.adapter, tenantId);
+    const resolved = [];
+    for (const id of ids) {
+      const record = await recordService.getRecord(id);
+      if (!record) {
+        continue;
+      }
+      const objectSchema = await this.schemaService.getObjectSchema(record.objectId);
+      if (!objectSchema) {
+        continue;
+      }
+      const label = this.resolveLabel(record.values, objectSchema.titleAttribute);
+      resolved.push({
+        id: record.id,
+        objectId: record.objectId,
+        objectName: objectSchema.name,
+        objectLabel: objectSchema.label,
+        objectIcon: objectSchema.icon,
+        label,
+        data: record.values
+      });
+    }
+    return resolved;
+  }
+  /**
+   * Find a relation attribute by ID
+   */
+  async findAttributeById(attributeId) {
+    const attribute = await this.adapter.attributes.findById(attributeId);
+    if (!attribute || attribute.type !== "relation") {
+      return null;
+    }
+    return {
+      ...attribute.config,
+      ...attribute
+    };
+  }
+  /**
+   * Resolve display label from record values
+   * Uses displayTemplate if provided, otherwise falls back to titleAttribute
+   */
+  resolveLabel(values, titleAttribute, displayTemplate) {
+    if (displayTemplate) {
+      return displayTemplate.replace(/\{(\w+)\}/g, (_, key) => {
+        const value = values[key];
+        return value !== void 0 && value !== null ? String(value) : "";
+      });
+    }
+    const titleValue = values[titleAttribute];
+    return titleValue !== void 0 && titleValue !== null ? String(titleValue) : "(Untitled)";
+  }
+};
+
+// src/runtime/services/record.service.ts
+var RecordService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+    this.schemaService = new ObjectSchemaService(adapter, registry);
+    this.relationService = new RelationService(adapter, registry);
+  }
+  /**
+   * Create a new record with validation
+   *
+   * @param objectId - Object UUID
+   * @param data - Record data (attribute values)
+   * @param options - Creation options
+   * @returns Created record with computed completionStatus
+   *
+   * @example
+   * ```typescript
+   * const service = new RecordService(adapter, "tenant-123");
+   *
+   * // Create a complete record (strict validation)
+   * const product = await service.createRecord("obj-product", {
+   *   name: "Nike Air Max",
+   *   price: 129.99,
+   *   status: "active"
+   * });
+   * // → product.completionStatus = "complete"
+   *
+   * // Create a draft record (allows missing required fields)
+   * const draft = await service.createRecord("obj-product", {
+   *   name: "Draft Product"
+   * }, { allowDraft: true });
+   * // → draft.completionStatus = "draft"
+   * ```
+   */
+  async createRecord(objectId, data, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
+    if (options?.validate !== false) {
+      if (options?.allowDraft) {
+        validateDraftOrThrow(schema, data);
+      } else {
+        validateObjectOrThrow(schema, data);
+      }
+      if (!options?.skipRelationValidation) {
+        await this.relationService.validateRelationsOrThrow(schema, data);
+      }
+    }
+    const completionStatus = computeRecordStatus(schema, data);
+    const record = await this.adapter.objectRecords.create({
+      tenantId: this.tenantId,
+      objectId,
+      data,
+      completionStatus
+    });
+    return record;
+  }
+  /**
+   * Get a record by ID
+   *
+   * @param recordId - Record UUID
+   * @param options - Query options
+   * @returns Record or null if not found
+   */
+  async getRecord(recordId, options) {
+    const record = await this.adapter.objectRecords.findById(recordId);
+    if (!record) {
+      return null;
+    }
+    if (options?.includeSchema) {
+      const schema = await this.schemaService.getObjectSchema(record.objectId);
+      const recordWithSchema = record;
+      recordWithSchema.schema = schema;
+      return recordWithSchema;
+    }
+    return record;
+  }
+  /**
+   * Get a record by ID or throw if not found
+   */
+  async getRecordOrThrow(recordId) {
+    const record = await this.getRecord(recordId);
+    if (!record) {
+      throw new Error(`Record with id "${recordId}" not found`);
+    }
+    return record;
+  }
+  /**
+   * Update a record with validation
+   *
+   * The completion status is automatically recalculated after each update.
+   * A draft record becomes complete when all required fields are filled.
+   *
+   * @param recordId - Record UUID
+   * @param data - Partial data to update
+   * @param options - Update options
+   * @returns Updated record with recalculated completionStatus
+   *
+   * @example
+   * ```typescript
+   * // Update a draft record to make it complete
+   * const updated = await service.updateRecord(draftId, {
+   *   price: 99.99,
+   *   status: "active"
+   * });
+   * // → updated.completionStatus = "complete" if all required fields now present
+   * ```
+   */
+  async updateRecord(recordId, data, options) {
+    const existing = await this.getRecordOrThrow(recordId);
+    const schema = await this.schemaService.getObjectSchema(existing.objectId);
+    const mergedData = { ...existing.values, ...data };
+    if (options?.validate !== false) {
+      if (options?.partial) {
+        validateDraftOrThrow(schema, mergedData);
+      } else {
+        validateObjectOrThrow(schema, mergedData);
+      }
+      if (!options?.skipRelationValidation) {
+        await this.relationService.validateRelationsOrThrow(schema, data);
+      }
+    }
+    const completionStatus = computeRecordStatus(schema, mergedData);
+    const updated = await this.adapter.objectRecords.update(recordId, {
+      ...data,
+      __completionStatus: completionStatus
+    });
+    return updated;
+  }
+  /**
+   * Delete a record
+   *
+   * @param recordId - Record UUID
+   * @param options - Delete options
+   */
+  async deleteRecord(recordId, options) {
+    if (options?.checkSystem) {
+      const record = await this.getRecordOrThrow(recordId);
+      const schema = await this.schemaService.getObjectSchema(record.objectId);
+      if (schema.system) {
+        throw new Error(`Cannot delete record of system object "${schema.label}"`);
+      }
+    }
+    await this.adapter.objectRecords.delete(recordId);
+  }
+  /**
+   * List records for an object with pagination
+   *
+   * @param objectId - Object UUID
+   * @param options - List options
+   * @returns Records and total count
+   */
+  async listRecords(objectId, options) {
+    return await this.adapter.objectRecords.list(this.tenantId, objectId, options);
+  }
+  /**
+   * Search records using full-text search
+   *
+   * @param objectId - Object UUID
+   * @param query - Search query
+   * @param options - Search options
+   * @returns Matching records and total count
+   */
+  async searchRecords(objectId, query, options) {
+    return await this.adapter.objectRecords.search(this.tenantId, objectId, query, options);
+  }
+  /**
+   * Validate data against object schema without saving
+   *
+   * @param objectId - Object UUID
+   * @param data - Data to validate
+   * @returns Validation result
+   */
+  async validateData(objectId, data) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
+    return validateObject(schema, data);
+  }
+  /**
+   * Compute the completion status for given data without saving.
+   * Useful for UI to show draft/complete status before submitting.
+   *
+   * @param objectId - Object UUID
+   * @param data - Data to check
+   * @returns Computed completion status
+   */
+  async computeStatus(objectId, data) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
+    return computeRecordStatus(schema, data);
+  }
+  /**
+   * Refresh the completion status of an existing record.
+   * Useful when schema changes and you need to recompute statuses.
+   *
+   * @param recordId - Record UUID
+   * @returns Updated completion status
+   */
+  async refreshRecordStatus(recordId) {
+    const record = await this.getRecordOrThrow(recordId);
+    const schema = await this.schemaService.getObjectSchema(record.objectId);
+    const newStatus = computeRecordStatus(schema, record.values);
+    if (record.completionStatus !== newStatus) {
+      await this.adapter.objectRecords.update(recordId, {
+        __completionStatus: newStatus
+      });
+    }
+    return newStatus;
+  }
+};
+
+// src/runtime/services/user-profile.service.ts
+var UserProfileService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Create a new user profile (typically after first auth)
+   *
+   * @param data - User profile creation data
+   * @returns Created user profile
+   *
+   * @example
+   * ```typescript
+   * const service = new UserProfileService(adapter, "tenant-123");
+   *
+   * // After Supabase auth
+   * const profile = await service.createProfile({
+   *   tenantId: "tenant-123",
+   *   authId: authUser.id,
+   *   email: authUser.email,
+   *   firstName: authUser.user_metadata.first_name,
+   *   lastName: authUser.user_metadata.last_name,
+   *   role: "member",
+   *   status: "active"
+   * });
+   * ```
+   */
+  async createProfile(data) {
+    if (data.tenantId !== this.tenantId) {
+      throw new Error(
+        `Tenant mismatch: service initialized with "${this.tenantId}" but data has "${data.tenantId}"`
+      );
+    }
+    const existing = await this.adapter.userProfiles.findByAuthId(data.authId);
+    if (existing) {
+      throw new Error(`User profile with authId "${data.authId}" already exists`);
+    }
+    const existingEmail = await this.adapter.userProfiles.findByEmail(this.tenantId, data.email);
+    if (existingEmail) {
+      throw new Error(`User profile with email "${data.email}" already exists in this tenant`);
+    }
+    return await this.adapter.userProfiles.create(data);
+  }
+  /**
+   * Get user profile by ID
+   */
+  async getProfile(profileId) {
+    return await this.adapter.userProfiles.findById(profileId);
+  }
+  /**
+   * Get user profile by ID or throw
+   */
+  async getProfileOrThrow(profileId) {
+    const profile = await this.getProfile(profileId);
+    if (!profile) {
+      throw new Error(`User profile with id "${profileId}" not found`);
+    }
+    return profile;
+  }
+  /**
+   * Get user profile by auth provider ID
+   *
+   * @param authId - Auth provider user ID (Supabase, Clerk, etc.)
+   * @returns User profile or null
+   */
+  async getProfileByAuthId(authId) {
+    return await this.adapter.userProfiles.findByAuthId(authId);
+  }
+  /**
+   * Get or create user profile (idempotent operation)
+   * Useful for auth callbacks - ensures profile exists
+   *
+   * @param authId - Auth provider user ID
+   * @param data - Profile data to create if doesn't exist
+   * @returns Existing or newly created profile
+   *
+   * @example
+   * ```typescript
+   * // In Supabase auth callback
+   * const profile = await service.getOrCreateProfile(
+   *   authUser.id,
+   *   {
+   *     tenantId: "tenant-123",
+   *     authId: authUser.id,
+   *     email: authUser.email,
+   *     role: "member",
+   *     status: "active"
+   *   }
+   * );
+   * ```
+   */
+  async getOrCreateProfile(authId, data) {
+    const existing = await this.getProfileByAuthId(authId);
+    if (existing) {
+      return existing;
+    }
+    return await this.createProfile(data);
+  }
+  /**
+   * Update user profile
+   */
+  async updateProfile(profileId, data) {
+    await this.getProfileOrThrow(profileId);
+    return await this.adapter.userProfiles.update(profileId, data);
+  }
+  /**
+   * Delete user profile
+   *
+   * @param profileId - Profile UUID
+   * @param options - Delete options
+   */
+  async deleteProfile(profileId, options) {
+    if (options?.checkAdmin) {
+      const profile = await this.getProfileOrThrow(profileId);
+      if (profile.role === "admin") {
+        const allProfiles = await this.listProfiles();
+        const adminCount = allProfiles.filter((p) => p.role === "admin").length;
+        if (adminCount <= 1) {
+          throw new Error("Cannot delete the last admin user");
+        }
+      }
+    }
+    await this.adapter.userProfiles.delete(profileId);
+  }
+  /**
+   * List all user profiles for the tenant
+   */
+  async listProfiles(options) {
+    return await this.adapter.userProfiles.list(this.tenantId, options);
+  }
+  /**
+   * Update last login timestamp
+   *
+   * @param profileId - Profile UUID
+   *
+   * @example
+   * ```typescript
+   * // After successful auth
+   * await service.updateLastLogin(profile.id);
+   * ```
+   */
+  async updateLastLogin(profileId) {
+    await this.adapter.userProfiles.updateLastLogin(profileId);
+  }
+  /**
+   * Change user role
+   *
+   * @param profileId - Profile UUID
+   * @param newRole - New role
+   */
+  async changeRole(profileId, newRole) {
+    return await this.updateProfile(profileId, { role: newRole });
+  }
+  /**
+   * Change user status
+   *
+   * @param profileId - Profile UUID
+   * @param newStatus - New status
+   */
+  async changeStatus(profileId, newStatus) {
+    return await this.updateProfile(profileId, { status: newStatus });
+  }
+  /**
+   * Get user by email
+   */
+  async getProfileByEmail(email) {
+    return await this.adapter.userProfiles.findByEmail(this.tenantId, email);
+  }
+  /**
+   * Check if user has role
+   */
+  async hasRole(profileId, role) {
+    const profile = await this.getProfile(profileId);
+    return profile?.role === role;
+  }
+  /**
+   * Check if user is admin
+   */
+  async isAdmin(profileId) {
+    return await this.hasRole(profileId, "admin");
+  }
+};
+
+// src/runtime/services/view.service.ts
+var ViewService = class {
+  constructor(adapter, nativeViews) {
+    this.adapter = adapter;
+    this.nativeViews = nativeViews;
+  }
+  /**
+   * Get all views for an object (native + custom)
+   *
+   * @param objectName - Object name
+   * @param tenantId - Tenant ID
+   * @returns All views for the object
+   */
+  async getViewsForObject(objectName, tenantId) {
+    const nativeViewDefs = this.nativeViews.getByObjectName(objectName);
+    const dbViews = await this.adapter.views.findByObjectName(tenantId, objectName);
+    const customViews = dbViews.filter((v) => !v.system).map(this.convertDBViewToDefinition);
+    return [...nativeViewDefs, ...customViews];
+  }
+  /**
+   * Get a specific view by name
+   *
+   * @param objectName - Object name
+   * @param viewName - View name
+   * @param tenantId - Tenant ID
+   * @returns View definition or null
+   */
+  async getView(objectName, viewName, tenantId) {
+    const nativeView = this.nativeViews.get(objectName, viewName);
+    if (nativeView) {
+      return nativeView;
+    }
+    const dbView = await this.adapter.views.findByName(tenantId, objectName, viewName);
+    if (dbView) {
+      return this.convertDBViewToDefinition(dbView);
+    }
+    return null;
+  }
+  /**
+   * Get the default view for an object
+   *
+   * Priority:
+   * 1. Custom view marked as default
+   * 2. Native view marked as default
+   * 3. First available view
+   *
+   * @param objectName - Object name
+   * @param tenantId - Tenant ID
+   * @returns Default view or null
+   */
+  async getDefaultView(objectName, tenantId) {
+    const views = await this.getViewsForObject(objectName, tenantId);
+    const customDefault = views.find((v) => v.default && !v.system);
+    if (customDefault) return customDefault;
+    const nativeDefault = views.find((v) => v.default && v.system);
+    if (nativeDefault) return nativeDefault;
+    return views[0] ?? null;
+  }
+  /**
+   * Create a custom view
+   *
+   * @param input - View definition
+   * @param tenantId - Tenant ID
+   * @returns Created view
+   */
+  async createView(input, tenantId) {
+    this.validateViewName(input.name);
+    const existing = await this.adapter.views.findByName(tenantId, input.objectName, input.name);
+    if (existing) {
+      throw new Error(`View "${input.name}" already exists for object "${input.objectName}"`);
+    }
+    if (this.nativeViews.has(input.objectName, input.name)) {
+      throw new Error(
+        `Cannot create view "${input.name}": a system view with this name already exists`
+      );
+    }
+    if (!input.tabs || input.tabs.length === 0) {
+      throw new Error("View must have at least one tab");
+    }
+    const dbView = await this.adapter.views.create({
+      tenantId,
+      objectName: input.objectName,
+      name: input.name,
+      label: input.label,
+      description: input.description,
+      icon: input.icon,
+      tabs: input.tabs,
+      default: input.default ?? false,
+      system: false,
+      // Custom views are never system
+      metadata: input.metadata
+    });
+    return this.convertDBViewToDefinition(dbView);
+  }
+  /**
+   * Update a custom view
+   *
+   * @param viewId - View ID
+   * @param input - Update data
+   * @returns Updated view
+   */
+  async updateView(viewId, input) {
+    const dbView = await this.adapter.views.findById(viewId);
+    if (!dbView) {
+      throw new Error(`View with id "${viewId}" not found`);
+    }
+    if (dbView.system) {
+      throw new Error("Cannot modify system views. System views are protected.");
+    }
+    if (input.tabs && input.tabs.length === 0) {
+      throw new Error("View must have at least one tab");
+    }
+    const updated = await this.adapter.views.update(viewId, {
+      label: input.label,
+      description: input.description,
+      icon: input.icon,
+      tabs: input.tabs,
+      default: input.default,
+      metadata: input.metadata
+    });
+    return this.convertDBViewToDefinition(updated);
+  }
+  /**
+   * Delete a custom view
+   *
+   * @param viewId - View ID
+   */
+  async deleteView(viewId) {
+    const dbView = await this.adapter.views.findById(viewId);
+    if (!dbView) {
+      throw new Error(`View with id "${viewId}" not found`);
+    }
+    if (dbView.system) {
+      throw new Error("Cannot delete system views. System views are protected.");
+    }
+    await this.adapter.views.delete(viewId);
+  }
+  /**
+   * Set a view as default for its object
+   *
+   * @param viewId - View ID
+   * @param tenantId - Tenant ID
+   * @returns Updated view
+   */
+  async setDefaultView(viewId, tenantId) {
+    const dbView = await this.adapter.views.findById(viewId);
+    if (!dbView) {
+      throw new Error(`View with id "${viewId}" not found`);
+    }
+    const currentViews = await this.adapter.views.findByObjectName(tenantId, dbView.objectName);
+    for (const v of currentViews) {
+      if (v.default && v.id !== viewId && !v.system) {
+        await this.adapter.views.update(v.id, { default: false });
+      }
+    }
+    const updated = await this.adapter.views.update(viewId, { default: true });
+    return this.convertDBViewToDefinition(updated);
+  }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
+  /**
+   * Validate view name format (kebab-case)
+   */
+  validateViewName(name) {
+    if (!name || name.length === 0) {
+      throw new Error("View name cannot be empty");
+    }
+    if (name.length > 63) {
+      throw new Error("View name is too long (max 63 characters)");
+    }
+    const kebabCaseRegex = /^[a-z][a-z0-9-]*$/;
+    if (!kebabCaseRegex.test(name)) {
+      throw new Error(
+        "Invalid view name format. Name must be in kebab-case (e.g., 'detail', 'list-view')"
+      );
+    }
+  }
+  /**
+   * Convert database view to ViewDefinition
+   */
+  convertDBViewToDefinition(dbView) {
+    return {
+      id: dbView.id,
+      name: dbView.name,
+      label: dbView.label,
+      description: dbView.description,
+      icon: dbView.icon,
+      object: dbView.objectName,
+      tabs: dbView.tabs,
+      default: dbView.default,
+      system: dbView.system,
+      metadata: dbView.metadata
+    };
+  }
+};
+
+// src/runtime/view-sync.ts
+async function syncNativeViews(adapter, nativeViewRegistry, options = {}) {
+  const result = {
+    success: true,
+    viewsSynced: 0,
+    viewsCreated: 0,
+    viewsUpdated: 0,
+    viewsDeleted: 0,
+    errors: []
+  };
+  const nativeViews = nativeViewRegistry.getAll();
+  if (options.verbose) {
+    console.info(`[ViewSync] Starting sync for ${nativeViews.length} native views...`);
+  }
+  try {
+    await adapter.transaction(async (tx) => {
+      const viewsByObject = await syncAllViews(tx, nativeViews, result, options);
+      await cleanupRemovedViews(tx, viewsByObject, result, options);
+    });
+  } catch (error) {
+    handleTransactionError(result, error);
+  }
+  logSyncComplete(result, options);
+  return result;
+}
+async function syncAllViews(tx, nativeViews, result, options) {
+  const viewsByObject = /* @__PURE__ */ new Map();
+  for (const nativeView of nativeViews) {
+    try {
+      await syncSingleView(tx, nativeView, result, options);
+      trackViewByObject(viewsByObject, nativeView);
+    } catch (error) {
+      handleViewSyncError(result, nativeView, error, options);
+    }
+  }
+  return viewsByObject;
+}
+function trackViewByObject(viewsByObject, nativeView) {
+  const objectViews = viewsByObject.get(nativeView.object) ?? [];
+  objectViews.push(nativeView.name);
+  viewsByObject.set(nativeView.object, objectViews);
+}
+function handleViewSyncError(result, nativeView, error, options) {
+  result.success = false;
+  result.errors.push({
+    viewName: nativeView.name,
+    objectName: nativeView.object,
+    error: error instanceof Error ? error.message : String(error)
+  });
+  if (options.verbose) {
+    console.error(`[ViewSync] \u2717 Failed to sync ${nativeView.object}:${nativeView.name}:`, error);
+  }
+}
+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}`);
+    }
+  }
+}
+function handleTransactionError(result, error) {
+  result.success = false;
+  result.errors.push({
+    viewName: "transaction",
+    objectName: "",
+    error: error instanceof Error ? error.message : String(error)
+  });
+}
+function logSyncComplete(result, options) {
+  if (options.verbose) {
+    console.info(
+      `[ViewSync] ${result.success ? "\u2713" : "\u2717"} Sync complete:
+  Views: ${result.viewsCreated} created, ${result.viewsUpdated} updated, ${result.viewsDeleted} deleted
+  Errors: ${result.errors.length}`
+    );
+  }
+}
+async function syncSingleView(adapter, nativeView, result, options) {
+  if (!nativeView.system) {
+    throw new Error(`View ${nativeView.name} is not marked as system`);
+  }
+  const existingView = await adapter.views.findSystemByName(nativeView.object, nativeView.name);
+  const isNew = !existingView;
+  if (isNew) {
+    result.viewsCreated++;
+  } else {
+    result.viewsUpdated++;
+  }
+  result.viewsSynced++;
+  if (options.dryRun) {
+    if (options.verbose) {
+      console.info(
+        `[ViewSync] Would ${isNew ? "create" : "update"} view: ${nativeView.object}:${nativeView.name}`
+      );
+    }
+    return;
+  }
+  await adapter.views.upsert({
+    tenantId: options.tenantId || "default",
+    objectName: nativeView.object,
+    name: nativeView.name,
+    label: nativeView.label,
+    description: nativeView.description,
+    icon: nativeView.icon,
+    tabs: nativeView.tabs,
+    default: nativeView.default ?? false,
+    system: true,
+    metadata: nativeView.metadata
+  });
+  if (options.verbose) {
+    console.info(
+      `[ViewSync] \u2713 Synced ${nativeView.object}:${nativeView.name}: ${nativeView.tabs.length} tabs`
+    );
+  }
+}
+async function verifyNativeViewsSync(adapter, nativeViewRegistry) {
+  const nativeViews = nativeViewRegistry.getAll();
+  for (const view2 of nativeViews) {
+    if (!view2.system) continue;
+    const existing = await adapter.views.findSystemByName(view2.object, view2.name);
+    if (!existing) {
+      return false;
+    }
+  }
+  return true;
+}
+async function getViewSyncPreview(adapter, nativeViewRegistry) {
+  return await syncNativeViews(adapter, nativeViewRegistry, { dryRun: true });
+}
+
+// src/runtime/sync.ts
+var BASE_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "name",
+  "label",
+  "type",
+  "required",
+  "system",
+  "unique",
+  "order"
+]);
+function extractAttributeConfig(attr) {
+  return Object.fromEntries(
+    Object.entries(attr).filter(
+      ([key, value]) => !BASE_ATTRIBUTE_KEYS.has(key) && value !== void 0
+    )
+  );
+}
+async function syncNativeObjects(adapter, nativeRegistry, options = {}) {
+  const result = {
+    success: true,
+    objectsSynced: 0,
+    attributesSynced: 0,
+    objectsCreated: 0,
+    objectsUpdated: 0,
+    attributesCreated: 0,
+    attributesUpdated: 0,
+    attributesDeleted: 0,
+    errors: []
+  };
+  const nativeObjects = nativeRegistry.getAll();
+  if (options.verbose) {
+    console.info(`[SyncService] Starting sync for ${nativeObjects.length} native objects...`);
+  }
+  try {
+    await adapter.transaction(async (tx) => {
+      for (const nativeObject of nativeObjects) {
+        try {
+          await syncSingleObject(tx, nativeObject, result, options);
+        } catch (error) {
+          result.success = false;
+          result.errors.push({
+            objectName: nativeObject.name,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          if (options.verbose) {
+            console.error(`[SyncService] \u2717 Failed to sync ${nativeObject.name}:`, error);
+          }
+        }
+      }
+    });
+  } catch (error) {
+    result.success = false;
+    result.errors.push({
+      objectName: "transaction",
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  if (options.verbose) {
+    console.info(
+      `[SyncService] ${result.success ? "\u2713" : "\u2717"} Sync complete:
+  Objects: ${result.objectsCreated} created, ${result.objectsUpdated} updated
+  Attributes: ${result.attributesCreated} created, ${result.attributesUpdated} updated, ${result.attributesDeleted} deleted
+  Errors: ${result.errors.length}`
+    );
+  }
+  return result;
+}
+async function syncSingleObject(adapter, nativeObject, result, options) {
+  if (!nativeObject.system) {
+    throw new Error(`Object ${nativeObject.name} is not marked as system`);
+  }
+  const existingObject = await adapter.objects.findSystemByName(nativeObject.name);
+  const isNew = !existingObject;
+  updateObjectStats(result, isNew);
+  if (options.dryRun) {
+    await handleDryRun(adapter, nativeObject, existingObject, result, options, isNew);
+    return;
+  }
+  const dbObject = await upsertObject(adapter, nativeObject, options);
+  await syncAttributes(adapter, nativeObject, dbObject, existingObject, result);
+  if (!isNew) {
+    await cleanupAttributes(adapter, dbObject.id, nativeObject, result);
+  }
+  logSyncSuccess(nativeObject, options);
+}
+function updateObjectStats(result, isNew) {
+  if (isNew) {
+    result.objectsCreated++;
+  } else {
+    result.objectsUpdated++;
+  }
+  result.objectsSynced++;
+}
+async function handleDryRun(adapter, nativeObject, existingObject, result, options, isNew) {
+  if (options.verbose) {
+    console.info(`[SyncService] Would ${isNew ? "create" : "update"} object: ${nativeObject.name}`);
+  }
+  for (const attr of nativeObject.attributes) {
+    const existingAttr = existingObject ? await adapter.attributes.findByObjectId(existingObject.id).then((attrs) => attrs.find((a) => a.name === attr.name)) : null;
+    if (existingAttr) {
+      result.attributesUpdated++;
+    } else {
+      result.attributesCreated++;
+    }
+    result.attributesSynced++;
+  }
+}
+async function upsertObject(adapter, nativeObject, options) {
+  return await adapter.objects.upsert({
+    tenantId: options.tenantId || "default",
+    system: true,
+    name: nativeObject.name,
+    label: nativeObject.label,
+    description: nativeObject.description,
+    metadata: nativeObject.metadata
+  });
+}
+async function syncAttributes(adapter, nativeObject, dbObject, existingObject, result) {
+  for (const [index, attr] of nativeObject.attributes.entries()) {
+    const existingAttr = existingObject ? await adapter.attributes.findByObjectId(dbObject.id).then((attrs) => attrs.find((a) => a.name === attr.name)) : null;
+    await adapter.attributes.upsert({
+      objectId: dbObject.id,
+      name: attr.name,
+      label: attr.label,
+      type: attr.type,
+      description: attr.description,
+      icon: attr.icon,
+      system: attr.system ?? true,
+      required: attr.required ?? false,
+      order: attr.order ?? index,
+      hidden: attr.hidden,
+      archived: attr.archived,
+      deprecated: attr.deprecated,
+      defaultValue: attr.defaultValue,
+      config: extractAttributeConfig(attr)
+    });
+    if (existingAttr) {
+      result.attributesUpdated++;
+    } else {
+      result.attributesCreated++;
+    }
+    result.attributesSynced++;
+  }
+}
+async function cleanupAttributes(adapter, objectId, nativeObject, result) {
+  const attributeNames = nativeObject.attributes.map((attr) => attr.name);
+  const deletedCount = await adapter.attributes.deleteByNames(objectId, attributeNames);
+  result.attributesDeleted += deletedCount;
+}
+function logSyncSuccess(nativeObject, options) {
+  if (options.verbose) {
+    console.info(
+      `[SyncService] \u2713 Synced ${nativeObject.name}: ${nativeObject.attributes.length} attributes`
+    );
+  }
+}
+async function verifyNativeObjectsSync(adapter, nativeRegistry) {
+  const nativeObjects = nativeRegistry.getAll();
+  for (const obj of nativeObjects) {
+    if (!obj.system) continue;
+    const existing = await adapter.objects.findSystemByName(obj.name);
+    if (!existing) {
+      return false;
+    }
+  }
+  return true;
+}
+async function getSyncPreview(adapter, nativeRegistry) {
+  return await syncNativeObjects(adapter, nativeRegistry, { dryRun: true });
+}
+async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}) {
+  if (options.verbose) {
+    console.info("[SyncAll] Starting full sync...");
+  }
+  const objectsResult = await syncNativeObjects(adapter, objectRegistry, options);
+  const viewsResult = await syncNativeViews(adapter, nativeViewRegistry, options);
+  const result = {
+    success: objectsResult.success && viewsResult.success,
+    objects: objectsResult,
+    views: viewsResult
+  };
+  if (options.verbose) {
+    console.info(
+      `[SyncAll] ${result.success ? "\u2713" : "\u2717"} Full sync complete:
+  Objects: ${objectsResult.objectsSynced} synced (${objectsResult.objectsCreated} created, ${objectsResult.objectsUpdated} updated)
+  Views: ${viewsResult.viewsSynced} synced (${viewsResult.viewsCreated} created, ${viewsResult.viewsUpdated} updated)
+  Errors: ${objectsResult.errors.length + viewsResult.errors.length}`
+    );
+  }
+  return result;
+}
+
+// src/types/geocoding.ts
+var NoopGeocodingAdapter = class {
+  async autocomplete() {
+    return await Promise.resolve([]);
+  }
+  async reverse() {
+    return await Promise.resolve(null);
+  }
+  async geocode() {
+    return await Promise.resolve(null);
+  }
+};
+
+export {
+  NoopGeocodingAdapter,
+  generateId,
+  generatePrefixedId,
+  text,
+  textarea,
+  number,
+  checkbox,
+  date,
+  phone,
+  currency,
+  status,
+  select,
+  multiselect,
+  location,
+  timestamp,
+  file,
+  user,
+  relation,
+  rating,
+  ObjectBuilder,
+  object,
+  GroupBuilder,
+  TableTabConfig,
+  CustomTabConfig,
+  TabBuilder,
+  ViewBuilder,
+  view,
+  group,
+  registry,
+  createTextValidator,
+  createNumberValidator,
+  createCheckboxValidator,
+  createDateValidator,
+  createPhoneValidator,
+  createCurrencyValidator,
+  createStatusValidator,
+  createSelectValidator,
+  createMultiselectValidator,
+  createLocationValidator,
+  createTimestampValidator,
+  createFileValidator,
+  createUserValidator,
+  createSingleRelationValidator,
+  createMultiRelationValidator,
+  createRelationValidator,
+  createRatingValidator,
+  createAttributeValidator,
+  createObjectValidator,
+  validateAttribute,
+  validateObject,
+  validateObjectOrThrow,
+  createDraftValidator,
+  validateDraft,
+  validateDraftOrThrow,
+  getMissingRequiredAttributes,
+  isRecordComplete,
+  computeRecordStatus,
+  createMockAdapter,
+  FileService,
+  GeocodingService,
+  ObjectSchemaService,
+  RelationService,
+  RecordService,
+  UserProfileService,
+  ViewService,
+  syncNativeViews,
+  verifyNativeViewsSync,
+  getViewSyncPreview,
+  syncNativeObjects,
+  verifyNativeObjectsSync,
+  getSyncPreview,
+  syncAll
+};