@stndrds/schema 0.1.0-alpha.14

package/dist/runtime.js

@@ -0,0 +1,3626 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  DEFAULT_LABEL_FALLBACK: () => DEFAULT_LABEL_FALLBACK,
+  FileService: () => FileService,
+  GeocodingService: () => GeocodingService,
+  GlobalSearchService: () => GlobalSearchService,
+  NoopGeocodingAdapter: () => NoopGeocodingAdapter,
+  NoopHookRegistry: () => NoopHookRegistry,
+  ObjectSchemaService: () => ObjectSchemaService,
+  RecordService: () => RecordService,
+  RelationService: () => RelationService,
+  UserProfileService: () => UserProfileService,
+  ViewService: () => ViewService,
+  createMockAdapter: () => createMockAdapter,
+  extractAttributeNames: () => extractAttributeNames,
+  getSyncPreview: () => getSyncPreview,
+  getViewSyncPreview: () => getViewSyncPreview,
+  isLabelExpression: () => isLabelExpression,
+  renderLabelExpression: () => renderLabelExpression,
+  syncAll: () => syncAll,
+  syncNativeObjects: () => syncNativeObjects,
+  syncNativeViews: () => syncNativeViews,
+  verifyNativeObjectsSync: () => verifyNativeObjectsSync,
+  verifyNativeViewsSync: () => verifyNativeViewsSync
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/runtime/hooks/hook.registry.ts
+var NoopHookRegistry = class {
+  async execute() {
+  }
+};
+
+// 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);
+  });
+}
+
+// src/runtime/template.ts
+var pipes = {
+  /** Convert to uppercase */
+  UPPER: (v) => String(v).toUpperCase(),
+  /** Convert to lowercase */
+  LOWER: (v) => String(v).toLowerCase(),
+  /** Capitalize first letter of each word */
+  capitalize: (v) => String(v).replace(/\b\w/g, (c) => c.toUpperCase()),
+  /** Trim whitespace from both ends */
+  trim: (v) => String(v).trim()
+};
+function getValue(obj, path) {
+  return path.split(".").reduce((acc, key) => {
+    if (acc == null || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, obj);
+}
+var DEFAULT_LABEL_FALLBACK = "(Untitled)";
+function renderLabelExpression(template, values, fallback = DEFAULT_LABEL_FALLBACK) {
+  const result = template.replace(/\{\{\s*([^}]+)\s*\}\}/g, (_, expr) => {
+    const parts = expr.split("|").map((s) => s.trim());
+    const path = parts[0];
+    let value = getValue(values, path);
+    if (value == null || value === "") return "";
+    for (let i = 1; i < parts.length; i++) {
+      const pipeName = parts[i].trim();
+      const fn = pipes[pipeName];
+      if (fn) {
+        value = fn(String(value));
+      }
+    }
+    return String(value);
+  }).trim();
+  return result || fallback;
+}
+function isLabelExpression(value) {
+  return /\{\{\s*\S+.*\}\}/.test(value);
+}
+function extractAttributeNames(template) {
+  const names = [];
+  const regex = /\{\{\s*([^|}]+)/g;
+  let match;
+  while ((match = regex.exec(template)) !== null) {
+    const path = match[1].trim();
+    const rootName = path.split(".")[0];
+    if (rootName && !names.includes(rootName)) {
+      names.push(rootName);
+    }
+  }
+  return names;
+}
+
+// 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,
+        pluralLabel: data.pluralLabel,
+        description: data.description,
+        icon: data.icon,
+        labelExpression: data.labelExpression,
+        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,
+            pluralLabel: data.pluralLabel,
+            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,
+        pluralLabel: data.pluralLabel,
+        description: data.description,
+        icon: data.icon,
+        labelExpression: data.labelExpression,
+        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 file = stores.files.get(id);
+      if (file?.deletedAt) return Promise.resolve(null);
+      return Promise.resolve(file ?? null);
+    },
+    create(data) {
+      const file = {
+        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(file.id, file);
+      return Promise.resolve(file);
+    },
+    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 file = stores.files.get(id);
+      if (file) {
+        file.deletedAt = /* @__PURE__ */ new Date();
+        stores.files.set(id, file);
+      }
+      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,
+        label: data.label,
+        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, __label, ...valueData } = data;
+      const updated = {
+        ...existing,
+        label: __label ?? existing.label,
+        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 });
+    },
+    globalSearch(tenantId, query, options) {
+      const lowerQuery = query.toLowerCase();
+      const objectsMap = /* @__PURE__ */ new Map();
+      for (const obj of stores.objects.values()) {
+        if (obj.tenantId === tenantId) {
+          objectsMap.set(obj.id, obj);
+        }
+      }
+      const allowedObjectIds = /* @__PURE__ */ new Set();
+      if (options?.objectNames && options.objectNames.length > 0) {
+        for (const obj of objectsMap.values()) {
+          if (options.objectNames.includes(obj.name)) {
+            allowedObjectIds.add(obj.id);
+          }
+        }
+      } else {
+        for (const obj of objectsMap.values()) {
+          allowedObjectIds.add(obj.id);
+        }
+      }
+      let matchingRecords = Array.from(stores.objectRecords.values()).filter((r) => {
+        if (r.tenantId !== tenantId) return false;
+        if (!allowedObjectIds.has(r.objectId)) return false;
+        return Object.values(r.values).some(
+          (val) => String(val).toLowerCase().includes(lowerQuery)
+        );
+      });
+      const total = matchingRecords.length;
+      if (options?.limit) {
+        matchingRecords = matchingRecords.slice(
+          options.offset ?? 0,
+          (options.offset ?? 0) + options.limit
+        );
+      }
+      const results = matchingRecords.map((r) => {
+        const obj = objectsMap.get(r.objectId);
+        const labelExpression = obj?.labelExpression ?? "{{ name }}";
+        return {
+          objectId: r.objectId,
+          objectName: obj?.name ?? "unknown",
+          objectLabel: obj?.label ?? "Unknown",
+          label: renderLabelExpression(labelExpression, r.values),
+          recordId: r.id,
+          values: r.values,
+          completionStatus: r.completionStatus,
+          createdAt: r.createdAt,
+          updatedAt: r.updatedAt
+        };
+      });
+      return Promise.resolve({ results, 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 view = stores.views.get(id);
+      if (!view) {
+        return Promise.reject(new Error(`View not found: ${id}`));
+      }
+      const updated = {
+        ...view,
+        ...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, view] of stores.views.entries()) {
+        if (view.objectName === objectName && view.system && !keepViewNames.includes(view.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 file = await this.adapter.files.findById(fileId);
+    if (file?.deletedAt) {
+      return null;
+    }
+    return file;
+  }
+  /**
+   * Get file by ID or throw
+   */
+  async getFileOrThrow(fileId) {
+    const file = await this.getFile(fileId);
+    if (!file) {
+      throw new Error(`File with id "${fileId}" not found`);
+    }
+    return file;
+  }
+  /**
+   * 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 file = await this.getFileOrThrow(fileId);
+      if (file.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 file = await this.getFileOrThrow(fileId);
+    const currentAllowed = file.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 file = await this.getFileOrThrow(fileId);
+    const currentAllowed = file.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 file = await this.getFile(fileId);
+    if (!file) {
+      return false;
+    }
+    if (file.visibility === "public") {
+      return true;
+    }
+    if (file.uploadedBy === userId) {
+      return true;
+    }
+    if (file.visibility === "restricted") {
+      return file.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 file = await this.getFileOrThrow(fileId);
+    const currentTags = file.tags || [];
+    const newTags = [.../* @__PURE__ */ new Set([...currentTags, ...tags])];
+    return await this.updateFile(fileId, { tags: newTags });
+  }
+  /**
+   * Remove tags from file
+   */
+  async removeTags(fileId, tags) {
+    const file = await this.getFileOrThrow(fileId);
+    const currentTags = file.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/runtime/services/global-search.service.ts
+var GlobalSearchService = class {
+  constructor(adapter, tenantId) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Search across all object records for the tenant
+   *
+   * @param query - Search query string
+   * @param options - Search options (pagination, object filters)
+   * @returns Matching records with object metadata and total count
+   *
+   * @example
+   * ```typescript
+   * // Basic search
+   * const { results, total } = await service.search("nike air");
+   *
+   * // With pagination
+   * const { results, total } = await service.search("nike", {
+   *   limit: 10,
+   *   offset: 20
+   * });
+   *
+   * // Filter by object types
+   * const { results, total } = await service.search("nike", {
+   *   objectNames: ["products", "orders"]
+   * });
+   * ```
+   */
+  async search(query, options) {
+    if (!query || query.trim().length === 0) {
+      return { results: [], total: 0 };
+    }
+    return await this.adapter.objectRecords.globalSearch(this.tenantId, query.trim(), {
+      limit: options?.limit ?? 20,
+      offset: options?.offset ?? 0,
+      objectNames: options?.objectNames,
+      includeObjectInfo: options?.includeObjectInfo ?? true
+    });
+  }
+  /**
+   * Search and group results by object type
+   *
+   * @param query - Search query string
+   * @param options - Search options
+   * @returns Results grouped by object name
+   */
+  async searchGrouped(query, options) {
+    const { results, total } = await this.search(query, {
+      ...options,
+      limit: 100,
+      // Get more for grouping
+      offset: 0
+    });
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const result of results) {
+      const existing = groupMap.get(result.objectName);
+      if (existing) {
+        existing.results.push(result);
+      } else {
+        groupMap.set(result.objectName, {
+          objectName: result.objectName,
+          objectLabel: result.objectLabel,
+          results: [result]
+        });
+      }
+    }
+    const groups = Array.from(groupMap.values()).map((g) => ({
+      ...g,
+      count: g.results.length
+    }));
+    groups.sort((a, b) => b.count - a.count);
+    return { groups, total };
+  }
+};
+
+// src/builders/attribute-validators.ts
+var import_constants = require("@stndrds/constants");
+var VALID_ICONS = new Set(import_constants.ICONS);
+
+// src/builders/object-builder.ts
+var import_zod = __toESM(require("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 the plural form of the label (e.g., "Products" for "Product")
+   * Used in UI when displaying collections
+   */
+  pluralLabel(value) {
+    this._pluralLabel = 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 label expression template for displaying records
+   * This is REQUIRED for every object.
+   *
+   * Supports variable interpolation with `{{ attribute }}` syntax
+   * and pipes for formatting: `{{ name | UPPER }}`, `{{ name | capitalize }}`
+   *
+   * Available pipes: UPPER, LOWER, capitalize, trim
+   *
+   * @param template - The label expression template
+   *
+   * @example
+   * ```typescript
+   * object({ name: "contacts", label: "Contact" })
+   *   .labelExpression("{{ firstName }} {{ lastName }}")
+   *   .attribute(text({ name: "firstName", label: "First Name" }).required())
+   *   .attribute(text({ name: "lastName", label: "Last Name" }).required())
+   * ```
+   */
+  labelExpression(template) {
+    this._labelExpression = template;
+    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");
+    }
+    if (!this._labelExpression) {
+      throw new Error(
+        `[ObjectBuilder] Object "${this.obj.name}" must have a labelExpression.
+The labelExpression defines how records are displayed in lists and relations.
+  \u2705 Example: .labelExpression("{{ name }}")
+  \u2705 Example: .labelExpression("{{ firstName }} {{ lastName }}")`
+      );
+    }
+    return {
+      ...this.obj,
+      pluralLabel: this._pluralLabel,
+      labelExpression: this._labelExpression
+    };
+  }
+  /**
+   * Validate object name format
+   * Must be kebab-case (slug format), max 63 characters
+   * @internal
+   */
+  validateName(name) {
+    if (name === void 0) {
+      return;
+    }
+    const objectNameSchema = import_zod.default.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 import_zod.default.ZodError) {
+        throw new Error(`[ObjectBuilder] ${error.errors[0].message}`);
+      }
+      throw error;
+    }
+  }
+};
+function object(config) {
+  return new ObjectBuilder(config);
+}
+
+// src/builders/view-builder.ts
+var import_zod2 = require("zod");
+
+// src/validation/validators.ts
+var import_zod3 = require("zod");
+var baseConfigSchema = import_zod3.z.object({
+  disabled: import_zod3.z.boolean().optional(),
+  placeholder: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional(),
+  defaultValue: import_zod3.z.unknown().optional(),
+  icon: import_zod3.z.string().optional(),
+  order: import_zod3.z.number().int().optional(),
+  hidden: import_zod3.z.boolean().optional(),
+  archived: import_zod3.z.boolean().optional(),
+  deprecated: import_zod3.z.boolean().optional(),
+  metadata: import_zod3.z.record(import_zod3.z.unknown()).optional()
+});
+var optionSchema = import_zod3.z.object({
+  id: import_zod3.z.string().min(1),
+  label: import_zod3.z.string().min(1),
+  value: import_zod3.z.string().min(1),
+  color: import_zod3.z.string().optional(),
+  icon: import_zod3.z.string().optional(),
+  description: import_zod3.z.string().optional(),
+  group: import_zod3.z.enum(["idle", "in_progress", "finished"]).optional()
+});
+var relationTargetSchema = import_zod3.z.object({
+  object: import_zod3.z.string().min(1),
+  displayTemplate: import_zod3.z.string().optional(),
+  filter: import_zod3.z.record(import_zod3.z.unknown()).optional()
+});
+var documentTypeConfigSchema = import_zod3.z.object({
+  type: import_zod3.z.enum([
+    "id_card",
+    "passport",
+    "incorporation_certificate",
+    "driver_license",
+    "birth_certificate",
+    "residence_permit",
+    "bank_statement",
+    "proof_of_address",
+    "custom"
+  ]),
+  label: import_zod3.z.string(),
+  faces: import_zod3.z.array(import_zod3.z.enum(["front", "back", "single"])),
+  attributeMapping: import_zod3.z.array(
+    import_zod3.z.object({
+      attributeId: import_zod3.z.string(),
+      extractedKey: import_zod3.z.string(),
+      face: import_zod3.z.enum(["front", "back", "single"]).optional(),
+      required: import_zod3.z.boolean().optional()
+    })
+  ).optional()
+});
+var fileVerificationConfigSchema = import_zod3.z.object({
+  enabled: import_zod3.z.boolean(),
+  documentTypes: import_zod3.z.array(documentTypeConfigSchema),
+  autoExtract: import_zod3.z.boolean().optional(),
+  autoValidate: import_zod3.z.boolean().optional()
+});
+var textConfigSchema = baseConfigSchema.extend({
+  minLength: import_zod3.z.number().int().min(0).optional(),
+  maxLength: import_zod3.z.number().int().min(1).optional(),
+  pattern: import_zod3.z.string().optional()
+});
+var textareaConfigSchema = baseConfigSchema;
+var numberConfigSchema = baseConfigSchema.extend({
+  min: import_zod3.z.number().optional(),
+  max: import_zod3.z.number().optional(),
+  unit: import_zod3.z.enum(["integer", "decimal", "percentage"]).optional(),
+  decimals: import_zod3.z.number().int().min(0).optional()
+});
+var checkboxConfigSchema = baseConfigSchema;
+var dateConfigSchema = baseConfigSchema.extend({
+  dateFormat: import_zod3.z.enum(["short", "long", "full", "relative"]).optional(),
+  minDate: import_zod3.z.string().optional(),
+  maxDate: import_zod3.z.string().optional()
+});
+var phoneConfigSchema = baseConfigSchema.extend({
+  defaultCountryCode: import_zod3.z.string().length(3).optional()
+});
+var currencyConfigSchema = baseConfigSchema.extend({
+  defaultCurrency: import_zod3.z.string().length(3).optional(),
+  allowedCurrencies: import_zod3.z.array(import_zod3.z.string().length(3)).optional()
+});
+var statusConfigSchema = baseConfigSchema.extend({
+  options: import_zod3.z.array(optionSchema).min(1)
+});
+var locationConfigSchema = baseConfigSchema.extend({
+  granularity: import_zod3.z.enum(["full", "address", "city", "state", "country", "coordinates"]),
+  enableAutocomplete: import_zod3.z.boolean().optional(),
+  enableMap: import_zod3.z.boolean().optional(),
+  defaultCountry: import_zod3.z.string().length(3).optional(),
+  allowedCountries: import_zod3.z.array(import_zod3.z.string().length(3)).optional(),
+  displayFormat: import_zod3.z.enum(["single_line", "multi_line", "compact"]).optional()
+});
+var timestampConfigSchema = baseConfigSchema.extend({
+  autoUpdate: import_zod3.z.boolean().optional()
+});
+var selectConfigSchema = baseConfigSchema.extend({
+  options: import_zod3.z.array(optionSchema).min(1)
+});
+var multiselectConfigSchema = baseConfigSchema.extend({
+  options: import_zod3.z.array(optionSchema).min(1)
+});
+var fileConfigSchema = baseConfigSchema.extend({
+  maxFiles: import_zod3.z.number().int().min(1).optional(),
+  maxSize: import_zod3.z.number().int().min(1).optional(),
+  allowedTypes: import_zod3.z.array(import_zod3.z.string()).optional(),
+  verification: fileVerificationConfigSchema.optional()
+});
+var userConfigSchema = baseConfigSchema.extend({
+  allowedRoles: import_zod3.z.array(import_zod3.z.string()).optional()
+});
+var relationConfigSchema = baseConfigSchema.extend({
+  targets: import_zod3.z.array(relationTargetSchema).min(1),
+  onDelete: import_zod3.z.enum(["restrict", "cascade", "set_null"]).optional(),
+  cardinality: import_zod3.z.enum(["one", "many"]),
+  minItems: import_zod3.z.number().int().min(0).optional(),
+  maxItems: import_zod3.z.number().int().min(1).optional()
+});
+var ratingConfigSchema = baseConfigSchema.extend({
+  max: import_zod3.z.number().int().min(1).optional(),
+  iconType: import_zod3.z.enum(["star", "heart", "thumbs", "number"]).optional()
+});
+var attributeConfigSchemas = {
+  text: textConfigSchema,
+  textarea: textareaConfigSchema,
+  number: numberConfigSchema,
+  checkbox: checkboxConfigSchema,
+  date: dateConfigSchema,
+  phone: phoneConfigSchema,
+  currency: currencyConfigSchema,
+  status: statusConfigSchema,
+  location: locationConfigSchema,
+  timestamp: timestampConfigSchema,
+  select: selectConfigSchema,
+  multiselect: multiselectConfigSchema,
+  file: fileConfigSchema,
+  user: userConfigSchema,
+  relation: relationConfigSchema,
+  rating: ratingConfigSchema
+};
+function getAttributeConfigSchema(type) {
+  return attributeConfigSchemas[type];
+}
+function parseAttributeConfig(type, config) {
+  const schema = getAttributeConfigSchema(type);
+  return schema.strip().parse(config);
+}
+function createTextValidator(attr) {
+  let schema = import_zod3.z.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 = import_zod3.z.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 import_zod3.z.boolean();
+}
+function createDateValidator(attr) {
+  return import_zod3.z.string().datetime({ message: `${attr.label} must be a valid ISO date` });
+}
+function createPhoneValidator(_attr) {
+  return import_zod3.z.object({
+    countryCode: import_zod3.z.string().length(3),
+    phoneNumber: import_zod3.z.string().min(1)
+  });
+}
+function createCurrencyValidator(_attr) {
+  return import_zod3.z.object({
+    code: import_zod3.z.string().length(3),
+    value: import_zod3.z.number().min(0)
+  });
+}
+function createStatusValidator(attr) {
+  const validValues = attr.options.map((opt) => opt.value);
+  return import_zod3.z.enum(validValues, {
+    errorMap: () => ({
+      message: `${attr.label} must be one of: ${validValues.join(", ")}`
+    })
+  });
+}
+function createSelectValidator(attr) {
+  const validValues = attr.options.map((opt) => opt.value);
+  return import_zod3.z.enum(validValues, {
+    errorMap: () => ({
+      message: `${attr.label} must be one of: ${validValues.join(", ")}`
+    })
+  });
+}
+function createMultiselectValidator(attr) {
+  const validValues = attr.options.map((opt) => opt.value);
+  return import_zod3.z.array(
+    import_zod3.z.enum(validValues, {
+      errorMap: () => ({
+        message: `Each value must be one of: ${validValues.join(", ")}`
+      })
+    })
+  );
+}
+function createLocationValidator(_attr) {
+  return import_zod3.z.object({
+    address: import_zod3.z.string().optional(),
+    address2: import_zod3.z.string().optional(),
+    city: import_zod3.z.string().optional(),
+    state: import_zod3.z.string().optional(),
+    postalCode: import_zod3.z.string().optional(),
+    country: import_zod3.z.string().length(3).optional(),
+    latitude: import_zod3.z.number().optional(),
+    longitude: import_zod3.z.number().optional()
+  });
+}
+function createTimestampValidator(_attr) {
+  return import_zod3.z.number().int().positive();
+}
+function createFileValidator(_attr) {
+  return import_zod3.z.string().uuid();
+}
+function createUserValidator(_attr) {
+  return import_zod3.z.string().uuid();
+}
+function createSingleRelationValidator(attr) {
+  const uuidSchema = import_zod3.z.string().uuid({
+    message: `${attr.label} must be a valid record ID`
+  });
+  return import_zod3.z.union([uuidSchema, import_zod3.z.null()]);
+}
+function createMultiRelationValidator(attr) {
+  const uuidSchema = import_zod3.z.string().uuid({
+    message: `Each ${attr.label} item must be a valid record ID`
+  });
+  let arraySchema = import_zod3.z.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 = import_zod3.z.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 import_zod3.z.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 import_zod3.z.object(shape);
+}
+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 import_zod3.z.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/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.pluralLabel) builder.pluralLabel(definition.pluralLabel);
+    if (definition.description) builder.description(definition.description);
+    if (definition.icon) builder.icon(definition.icon);
+    if (definition.metadata) builder.metadata(definition.metadata);
+    builder.labelExpression(definition.labelExpression);
+    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 validatedConfigs = [];
+    if (objectDef.attributes.length > 0) {
+      for (const attr of objectDef.attributes) {
+        const config = await this.validateAttributeInput(
+          attr,
+          tenantId
+        );
+        validatedConfigs.push(config);
+      }
+    }
+    const metadata = {
+      ...objectDef.metadata,
+      icon: objectDef.icon
+    };
+    const dbObject = await this.adapter.objects.create({
+      tenantId,
+      name: objectDef.name,
+      label: objectDef.label,
+      pluralLabel: objectDef.pluralLabel,
+      description: objectDef.description,
+      labelExpression: objectDef.labelExpression,
+      system: false,
+      // Always false for custom objects
+      metadata
+    });
+    const createdAttributes = [];
+    if (objectDef.attributes.length > 0) {
+      for (let i = 0; i < objectDef.attributes.length; i++) {
+        const attr = objectDef.attributes[i];
+        const config = validatedConfigs[i];
+        const dbAttr = await this.adapter.attributes.create({
+          objectId: dbObject.id,
+          name: attr.name,
+          label: attr.label,
+          type: attr.type,
+          required: attr.required ?? false,
+          unique: false,
+          system: false,
+          config
+        });
+        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
+   * @param tenantId - Tenant ID (required for relation validation)
+   * @returns Created Attribute
+   */
+  async addAttributeToObject(objectId, attribute, tenantId) {
+    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 config = await this.validateAttributeInput(attribute, tenantId);
+    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
+    });
+    return this.convertDBAttributeToAttribute(dbAttr);
+  }
+  /**
+   * Update an attribute
+   * Can only update custom attributes (system=false)
+   *
+   * @param attributeId - Attribute UUID
+   * @param updates - Partial attribute updates
+   * @param tenantId - Tenant ID (required for relation validation)
+   * @returns Updated Attribute
+   */
+  async updateAttribute(attributeId, updates, tenantId) {
+    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 mergedInput = {
+      name: dbAttr.name,
+      label: updates.label ?? dbAttr.label,
+      type: dbAttr.type,
+      required: updates.required ?? dbAttr.required,
+      ...dbAttr.config,
+      ...updates
+    };
+    const config = this.buildAttributeConfig(mergedInput);
+    if (dbAttr.type === "relation" && updates.targets) {
+      await this.validateRelationTargets(mergedInput, tenantId);
+    }
+    const updatedDbAttr = await this.adapter.attributes.update(attributeId, {
+      label: updates.label,
+      required: updates.required,
+      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));
+  }
+  /**
+   * Update a custom object
+   * Can only update custom objects (system=false)
+   *
+   * @param objectId - Object UUID
+   * @param updates - Partial object updates
+   * @returns Updated ObjectDefinition
+   *
+   * @example
+   * ```typescript
+   * const updated = await service.updateObject("obj-123", {
+   *   label: "Updated Label",
+   *   description: "New description",
+   * });
+   * ```
+   */
+  async updateObject(objectId, updates) {
+    const dbObject = await this.adapter.objects.findById(objectId);
+    if (!dbObject) {
+      throw new Error(`Object with id "${objectId}" not found`);
+    }
+    if (dbObject.system) {
+      throw new Error(
+        `Cannot modify system object "${dbObject.name}". System objects are protected.`
+      );
+    }
+    let metadata = dbObject.metadata;
+    if (updates.icon !== void 0 || updates.metadata !== void 0) {
+      metadata = {
+        ...dbObject.metadata,
+        ...updates.metadata,
+        icon: updates.icon ?? dbObject.metadata?.icon
+      };
+    }
+    const updatedDbObject = await this.adapter.objects.update(objectId, {
+      label: updates.label,
+      pluralLabel: updates.pluralLabel,
+      description: updates.description,
+      labelExpression: updates.labelExpression,
+      metadata
+    });
+    const dbAttributes = await this.adapter.attributes.findByObjectId(objectId);
+    return this.convertDBObjectToDefinition(updatedDbObject, dbAttributes);
+  }
+  /**
+   * Delete a custom object
+   * Can only delete custom objects (system=false)
+   * This will also delete all associated attributes and records
+   *
+   * @param objectId - Object UUID
+   *
+   * @example
+   * ```typescript
+   * await service.deleteObject("obj-123");
+   * ```
+   */
+  async deleteObject(objectId) {
+    const dbObject = await this.adapter.objects.findById(objectId);
+    if (!dbObject) {
+      throw new Error(`Object with id "${objectId}" not found`);
+    }
+    if (dbObject.system) {
+      throw new Error(
+        `Cannot delete system object "${dbObject.name}". System objects are protected.`
+      );
+    }
+    await this.adapter.objects.delete(objectId);
+  }
+  /**
+   * 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)
+    );
+    return {
+      id: dbObject.id,
+      name: dbObject.name,
+      label: dbObject.label,
+      pluralLabel: dbObject.pluralLabel,
+      description: dbObject.description,
+      icon: dbObject.metadata?.icon,
+      labelExpression: dbObject.labelExpression,
+      attributes,
+      system: dbObject.system,
+      metadata: dbObject.metadata
+    };
+  }
+  /**
+   * Validate attribute input and return parsed config
+   * Validates: name format, config schema, relation targets
+   * @internal
+   */
+  async validateAttributeInput(attribute, tenantId) {
+    this.validateAttributeName(attribute.name);
+    const config = this.buildAttributeConfig(attribute);
+    if (attribute.type === "relation") {
+      await this.validateRelationTargets(attribute, tenantId);
+    }
+    return config;
+  }
+  /**
+   * Build and validate attribute config from input
+   * Uses Zod schema to validate and strip unknown properties
+   * @internal
+   */
+  buildAttributeConfig(attribute) {
+    const {
+      name: _,
+      label: __,
+      type: ___,
+      required: ____,
+      unique: _____,
+      ...configInput
+    } = attribute;
+    try {
+      return parseAttributeConfig(attribute.type, configInput);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Invalid config for ${attribute.type} attribute: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Validate that relation target objects exist
+   * @internal
+   */
+  async validateRelationTargets(attribute, tenantId) {
+    const targets = attribute.targets;
+    if (!targets || targets.length === 0) {
+      throw new Error("Relation attribute must have at least one target object");
+    }
+    const cardinality = attribute.cardinality;
+    if (!(cardinality && ["one", "many"].includes(cardinality))) {
+      throw new Error("Relation attribute must specify cardinality: 'one' or 'many'");
+    }
+    for (const target of targets) {
+      if (!target.object) {
+        throw new Error("Each relation target must specify an object name");
+      }
+      let targetObject = tenantId ? await this.adapter.objects.findByName(tenantId, target.object) : null;
+      if (!targetObject) {
+        targetObject = await this.adapter.objects.findSystemByName(target.object);
+      }
+      if (!targetObject) {
+        const nativeObject = this.nativeRegistry.getByName(target.object);
+        if (!nativeObject) {
+          throw new Error(
+            `Relation target object "${target.object}" does not exist. Make sure the object is created before adding a relation to it.`
+          );
+        }
+      }
+    }
+  }
+  /**
+   * 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/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 template = target.displayTemplate || objectSchema.labelExpression;
+        const label = renderLabelExpression(template, record.values);
+        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 = renderLabelExpression(objectSchema.labelExpression, record.values);
+      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
+    };
+  }
+};
+
+// src/runtime/services/record.service.ts
+var RecordService = class {
+  constructor(adapter, tenantId, options) {
+    this.adapter = adapter;
+    this.tenantId = tenantId;
+    this.schemaService = new ObjectSchemaService(adapter, registry);
+    this.relationService = new RelationService(adapter, registry);
+    this.hookRegistry = options?.hookRegistry ?? new NoopHookRegistry();
+  }
+  /**
+   * Compute display label from schema expression
+   * Automatically resolves relation attribute values to their labels
+   * @internal
+   */
+  async computeLabel(schema, values) {
+    const attrNames = extractAttributeNames(schema.labelExpression);
+    const relationAttrs = schema.attributes.filter(
+      (attr) => attr.type === "relation" && attrNames.includes(attr.name)
+    );
+    if (relationAttrs.length === 0) {
+      return renderLabelExpression(schema.labelExpression, values);
+    }
+    const idsToResolve = [];
+    for (const attr of relationAttrs) {
+      const val = values[attr.name];
+      if (typeof val === "string") {
+        idsToResolve.push(val);
+      } else if (Array.isArray(val) && typeof val[0] === "string") {
+        idsToResolve.push(val[0]);
+      }
+    }
+    if (idsToResolve.length === 0) {
+      return renderLabelExpression(schema.labelExpression, values);
+    }
+    const resolved = await this.relationService.resolveIds(idsToResolve, this.tenantId);
+    const resolvedMap = new Map(resolved.map((r) => [r.id, r.label]));
+    const enrichedValues = { ...values };
+    for (const attr of relationAttrs) {
+      const val = values[attr.name];
+      if (typeof val === "string" && resolvedMap.has(val)) {
+        enrichedValues[attr.name] = resolvedMap.get(val);
+      } else if (Array.isArray(val) && typeof val[0] === "string" && resolvedMap.has(val[0])) {
+        enrichedValues[attr.name] = resolvedMap.get(val[0]);
+      }
+    }
+    return renderLabelExpression(schema.labelExpression, enrichedValues);
+  }
+  /**
+   * Create a new record with validation
+   *
+   * Triggers beforeCreate and afterCreate hooks if a HookRegistry is configured.
+   *
+   * @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);
+    const hookCtx = this.buildCreateHookContext(schema, data, options?.hookMetadata);
+    if (!options?.skipHooks) {
+      await this.hookRegistry.execute("beforeCreate", schema.name, hookCtx);
+    }
+    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 label = await this.computeLabel(schema, data);
+    const record = await this.adapter.objectRecords.create({
+      tenantId: this.tenantId,
+      objectId,
+      data,
+      label,
+      completionStatus
+    });
+    if (!options?.skipHooks) {
+      const afterCtx = {
+        ...hookCtx,
+        recordId: record.id,
+        record
+      };
+      await this.hookRegistry.execute("afterCreate", schema.name, afterCtx);
+    }
+    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.
+   *
+   * Triggers beforeUpdate and afterUpdate hooks if a HookRegistry is configured.
+   *
+   * @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 };
+    const changedAttributes = Object.keys(data).filter((key) => existing.values[key] !== data[key]);
+    const hookCtx = this.buildHookContext(
+      schema,
+      existing,
+      data,
+      mergedData,
+      changedAttributes,
+      options?.hookMetadata
+    );
+    if (!options?.skipHooks) {
+      await this.hookRegistry.execute("beforeUpdate", schema.name, hookCtx);
+    }
+    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 label = await this.computeLabel(schema, mergedData);
+    const updated = await this.adapter.objectRecords.update(recordId, {
+      ...data,
+      __completionStatus: completionStatus,
+      __label: label
+    });
+    if (!options?.skipHooks) {
+      const afterCtx = {
+        ...hookCtx,
+        record: updated
+      };
+      await this.hookRegistry.execute("afterUpdate", schema.name, afterCtx);
+    }
+    return updated;
+  }
+  /**
+   * Build hook context for update operations
+   * @internal
+   */
+  buildHookContext(schema, existing, newData, mergedData, changedAttributes, metadata) {
+    const oldValuesSnapshot = { ...existing.values };
+    return {
+      objectId: schema.id,
+      objectName: schema.name,
+      recordId: existing.id,
+      tenantId: this.tenantId,
+      record: existing,
+      oldValues: oldValuesSnapshot,
+      newValues: mergedData,
+      changedAttributes,
+      getChange: (attr) => ({
+        oldValue: oldValuesSnapshot[attr],
+        newValue: newData[attr] ?? oldValuesSnapshot[attr],
+        changed: changedAttributes.includes(attr)
+      }),
+      metadata: metadata ?? {},
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Build hook context for create operations (no existing record)
+   * @internal
+   */
+  buildCreateHookContext(schema, data, metadata) {
+    const attributeNames = Object.keys(data);
+    return {
+      objectId: schema.id,
+      objectName: schema.name,
+      recordId: "",
+      // Will be set after creation
+      tenantId: this.tenantId,
+      record: null,
+      // Will be set after creation
+      oldValues: {},
+      newValues: data,
+      changedAttributes: attributeNames,
+      // All attributes are "new"
+      getChange: (attr) => ({
+        oldValue: void 0,
+        newValue: data[attr],
+        changed: attributeNames.includes(attr)
+      }),
+      metadata: metadata ?? {},
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Build hook context for delete operations
+   * @internal
+   */
+  buildDeleteHookContext(schema, record, metadata) {
+    const attributeNames = Object.keys(record.values);
+    return {
+      objectId: schema.id,
+      objectName: schema.name,
+      recordId: record.id,
+      tenantId: this.tenantId,
+      record,
+      oldValues: record.values,
+      newValues: {},
+      changedAttributes: attributeNames,
+      // All attributes are being "removed"
+      getChange: (attr) => ({
+        oldValue: record.values[attr],
+        newValue: void 0,
+        changed: attributeNames.includes(attr)
+      }),
+      metadata: metadata ?? {},
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  /**
+   * Delete a record
+   *
+   * Triggers beforeDelete and afterDelete hooks if a HookRegistry is configured.
+   *
+   * @param recordId - Record UUID
+   * @param options - Delete options
+   */
+  async deleteRecord(recordId, options) {
+    const record = await this.getRecordOrThrow(recordId);
+    const schema = await this.schemaService.getObjectSchema(record.objectId);
+    if (options?.checkSystem) {
+      if (schema.system) {
+        throw new Error(`Cannot delete record of system object "${schema.label}"`);
+      }
+    }
+    const hookCtx = this.buildDeleteHookContext(schema, record, options?.hookMetadata);
+    if (!options?.skipHooks) {
+      await this.hookRegistry.execute("beforeDelete", schema.name, hookCtx);
+    }
+    await this.adapter.objectRecords.delete(recordId);
+    if (!options?.skipHooks) {
+      await this.hookRegistry.execute("afterDelete", schema.name, hookCtx);
+    }
+  }
+  /**
+   * 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 view of nativeViews) {
+    if (!view.system) continue;
+    const existing = await adapter.views.findSystemByName(view.object, view.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,
+    labelExpression: nativeObject.labelExpression,
+    icon: nativeObject.icon,
+    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);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_LABEL_FALLBACK,
+  FileService,
+  GeocodingService,
+  GlobalSearchService,
+  NoopGeocodingAdapter,
+  NoopHookRegistry,
+  ObjectSchemaService,
+  RecordService,
+  RelationService,
+  UserProfileService,
+  ViewService,
+  createMockAdapter,
+  extractAttributeNames,
+  getSyncPreview,
+  getViewSyncPreview,
+  isLabelExpression,
+  renderLabelExpression,
+  syncAll,
+  syncNativeObjects,
+  syncNativeViews,
+  verifyNativeObjectsSync,
+  verifyNativeViewsSync
+});