@stndrds/schema 0.1.0-alpha.14

package/dist/chunk-QX4U6U6K.mjs

@@ -0,0 +1,2484 @@
+// 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,
+        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,
+            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,
+        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,
+        system: data.system ?? false,
+        required: data.required ?? false,
+        unique: data.unique ?? false,
+        orderIndex: data.orderIndex ?? 0,
+        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,
+            system: data.system ?? attr.system,
+            required: data.required ?? attr.required,
+            unique: data.unique ?? attr.unique,
+            orderIndex: data.orderIndex ?? attr.orderIndex,
+            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,
+        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 updated = {
+        ...existing,
+        values: { ...existing.values, ...data },
+        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 createMockAdapter() {
+  const stores = {
+    objects: /* @__PURE__ */ new Map(),
+    attributes: /* @__PURE__ */ new Map(),
+    userProfiles: /* @__PURE__ */ new Map(),
+    files: /* @__PURE__ */ new Map(),
+    objectRecords: /* @__PURE__ */ new Map()
+  };
+  const adapter = {
+    objects: createMockObjectsRepository(stores),
+    attributes: createMockAttributesRepository(stores),
+    userProfiles: createMockUserProfilesRepository(stores),
+    files: createMockFilesRepository(stores),
+    objectRecords: createMockObjectRecordsRepository(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();
+    }
+  };
+  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/builders/attribute-builders.ts
+import { z } from "zod";
+var BaseAttributeBuilder = class {
+  constructor(type, name, label) {
+    this.validateVariableName(name);
+    this.attr = {
+      name,
+      label,
+      type,
+      required: false
+    };
+  }
+  /**
+   * Validate attribute name as valid variable identifier
+   * Accepts: camelCase, snake_case, PascalCase, UPPER_CASE
+   */
+  validateVariableName(name) {
+    const variableNameSchema = z.string().min(1, "Attribute name cannot be empty").max(63, "Attribute name is too long (max 63 characters)").regex(/^[a-zA-Z_][a-zA-Z0-9_]*$/, {
+      message: "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'"
+    });
+    try {
+      variableNameSchema.parse(name);
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(`[AttributeBuilder] ${error.errors[0].message}`);
+      }
+      throw error;
+    }
+  }
+  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) {
+    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) {
+    this.attr.options = value;
+    return this;
+  }
+  option(config) {
+    if (!this.attr.options) {
+      this.attr.options = [];
+    }
+    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) {
+    this.attr.options = value;
+    return this;
+  }
+  option(config) {
+    if (!this.attr.options) {
+      this.attr.options = [];
+    }
+    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) {
+    this.attr.options = value;
+    return this;
+  }
+  option(config) {
+    if (!this.attr.options) {
+      this.attr.options = [];
+    }
+    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 RelationAttributeBuilder = class extends BaseAttributeBuilder {
+  constructor(name, label) {
+    super("relation", name, label);
+  }
+  relation(objectIds) {
+    this.attr.relation = objectIds;
+    return this;
+  }
+  limit(value) {
+    this.attr.limit = value;
+    return this;
+  }
+  cascadeDelete() {
+    this.attr.cascadeDelete = true;
+    return this;
+  }
+  required() {
+    this.setRequired(true);
+    return this;
+  }
+  optional() {
+    this.setRequired(false);
+    return this;
+  }
+};
+function relation(config) {
+  return new RelationAttributeBuilder(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 z2 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;
+  }
+  /**
+   * 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");
+    }
+    return this.obj;
+  }
+  /**
+   * Validate object name format
+   * Must be kebab-case (slug format), max 63 characters
+   * @internal
+   */
+  validateName(name) {
+    if (name === void 0) {
+      return;
+    }
+    const objectNameSchema = z2.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 z2.ZodError) {
+        throw new Error(`[ObjectBuilder] ${error.errors[0].message}`);
+      }
+      throw error;
+    }
+  }
+};
+function object(config) {
+  return new ObjectBuilder(config);
+}
+
+// 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,
+          unique: attr.unique ?? 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,
+            unique: 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)
+   */
+  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);
+  }
+  /**
+   * 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 customAttributes = dbAttributes.filter((attr) => !attr.system);
+    const customAttrs = customAttributes.map(
+      (dbAttr) => this.convertDBAttributeToAttribute(dbAttr)
+    );
+    return {
+      ...nativeObject,
+      id: dbObject.id,
+      attributes: [
+        ...nativeObject.attributes,
+        // System attributes from code
+        ...customAttrs
+        // Custom attributes from DB
+      ]
+    };
+  }
+  /**
+   * Convert DB object + attributes to ObjectDefinition
+   * @internal
+   */
+  convertDBObjectToDefinition(dbObject, dbAttributes) {
+    const attributes = dbAttributes.map(
+      (dbAttr) => this.convertDBAttributeToAttribute(dbAttr)
+    );
+    return {
+      id: dbObject.id,
+      name: dbObject.name,
+      label: dbObject.label,
+      description: dbObject.description,
+      icon: dbObject.metadata?.icon,
+      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 createRelationValidator(_attr) {
+  return z3.string().uuid();
+}
+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;
+}
+
+// src/runtime/services/record.service.ts
+var RecordService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+    this.schemaService = new ObjectSchemaService(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
+   *
+   * @example
+   * ```typescript
+   * const service = new RecordService(adapter, "tenant-123");
+   *
+   * const product = await service.createRecord("obj-product", {
+   *   name: "Nike Air Max",
+   *   price: 129.99,
+   *   sku: "NIKE-AM-001"
+   * });
+   * ```
+   */
+  async createRecord(objectId, data, options) {
+    const schema = await this.schemaService.getObjectSchema(objectId);
+    if (options?.validate !== false) {
+      validateObjectOrThrow(schema, data);
+    }
+    const record = await this.adapter.objectRecords.create({
+      tenantId: this.tenantId,
+      objectId,
+      data
+    });
+    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
+   *
+   * @param recordId - Record UUID
+   * @param data - Partial data to update
+   * @param options - Update options
+   * @returns Updated record
+   */
+  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 && !options?.partial) {
+      validateObjectOrThrow(schema, mergedData);
+    }
+    const updated = await this.adapter.objectRecords.update(recordId, data);
+    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);
+  }
+};
+
+// 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/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,
+      system: attr.system ?? true,
+      required: attr.required ?? false,
+      orderIndex: attr.order ?? index,
+      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 });
+}
+
+export {
+  generateId,
+  generatePrefixedId,
+  text,
+  textarea,
+  number,
+  checkbox,
+  date,
+  phone,
+  currency,
+  status,
+  select,
+  multiselect,
+  location,
+  timestamp,
+  file,
+  user,
+  relation,
+  rating,
+  ObjectBuilder,
+  object,
+  registry,
+  createTextValidator,
+  createNumberValidator,
+  createCheckboxValidator,
+  createDateValidator,
+  createPhoneValidator,
+  createCurrencyValidator,
+  createStatusValidator,
+  createSelectValidator,
+  createMultiselectValidator,
+  createLocationValidator,
+  createTimestampValidator,
+  createFileValidator,
+  createUserValidator,
+  createRelationValidator,
+  createRatingValidator,
+  createAttributeValidator,
+  createObjectValidator,
+  validateAttribute,
+  validateObject,
+  validateObjectOrThrow,
+  createMockAdapter,
+  FileService,
+  ObjectSchemaService,
+  RecordService,
+  UserProfileService,
+  syncNativeObjects,
+  verifyNativeObjectsSync,
+  getSyncPreview
+};