@stndrds/schema 0.1.0-alpha.56 → 0.1.0-alpha.58

package/dist/{chunk-LOOGQL6M.mjs → chunk-JRY236AO.mjs}

@@ -1,40 +1,22 @@
+import {
+  asTenantId,
+  asUserId,
+  generateId
+} from "./chunk-V2RPPE2Y.mjs";
+import {
+  computeRecordStatus,
+  formatZodErrors,
+  parseAttributeConfig,
+  validateDraftOrThrow,
+  validateObject,
+  validateObjectOrThrow
+} from "./chunk-SV4BCGQU.mjs";
 import {
   __require
 } from "./chunk-Y6FXYEAI.mjs";
 
 // src/runtime/auth/workflow-jwt.service.ts
 import { SignJWT, importPKCS8, importSPKI, jwtVerify } from "jose";
-
-// src/utils.ts
-function asTenantId(id) {
-  return id;
-}
-function asUserId(id) {
-  return id;
-}
-function generateId() {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID();
-  }
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-function generatePrefixedId(prefix) {
-  return `${prefix}_${generateId()}`;
-}
-function slugify(input) {
-  return input.normalize("NFD").replace(/\p{M}/gu, "").toLowerCase().replace(/[^a-z0-9\s_-]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-");
-}
-function generateTemplateName(label) {
-  const slug = slugify(label) || "template";
-  const suffix = generateId().slice(0, 8);
-  return `${slug}-${suffix}`;
-}
-
-// src/runtime/auth/workflow-jwt.service.ts
 var WorkflowJwtService = class _WorkflowJwtService {
   constructor(config) {
     this.config = config;
@@ -212,6 +194,26 @@ var WorkflowJwtService = class _WorkflowJwtService {
   }
 };
 
+// src/lib/object-helpers.ts
+function isEmpty(obj) {
+  if (obj === null || obj === void 0) {
+    return true;
+  }
+  if (typeof obj !== "object") {
+    return false;
+  }
+  return Object.keys(obj).length === 0;
+}
+function isNotEmpty(obj) {
+  return obj !== null && obj !== void 0 && typeof obj === "object" && Object.keys(obj).length > 0;
+}
+function toUndefinedIfEmpty(obj) {
+  return isNotEmpty(obj) ? obj : void 0;
+}
+function hasProperties(obj) {
+  return isNotEmpty(obj);
+}
+
 // src/runtime/cache.ts
 function fnv1aHash(str) {
   let hash = 2166136261;
@@ -222,7 +224,7 @@ function fnv1aHash(str) {
   return hash.toString(16).padStart(8, "0");
 }
 function hashOptions(options) {
-  if (options === null || options === void 0 || typeof options === "object" && Object.keys(options).length === 0) {
+  if (isEmpty(options)) {
     return "default";
   }
   const sortedJson = JSON.stringify(options, (_, value) => {
@@ -543,7 +545,7 @@ var TenantContextError = class _TenantContextError extends Error {
   }
 };
 
-// src/runtime/context/schema-context.ts
+// src/runtime/context/feature-flags-context.ts
 var browserStub = {
   getStore: () => void 0,
   run: (_store, callback) => callback()
@@ -581,22 +583,106 @@ function getStorage() {
   storageInstance = browserStub;
   return storageInstance;
 }
-function getSchemaFromContext(objectId) {
+var FeatureFlagsContextError = class _FeatureFlagsContextError extends Error {
+  constructor(message) {
+    super(
+      message ?? "No feature flags context found. This usually means:\n  - HTTP request: Missing FeatureFlagsInterceptor\n  - Background job: Wrap with runWithFeatureFlags()\n  - Test: Wrap test body with runWithFeatureFlags()\n\nTip: FeatureFlagsInterceptor must run AFTER TenantContextInterceptor."
+    );
+    this.name = "FeatureFlagsContextError";
+    if ("captureStackTrace" in Error) {
+      Error.captureStackTrace(
+        this,
+        _FeatureFlagsContextError
+      );
+    }
+  }
+};
+function getContext() {
+  const ctx = getStorage().getStore();
+  if (!ctx) {
+    throw new FeatureFlagsContextError();
+  }
+  return ctx;
+}
+function isFeatureEnabled(flagName) {
+  return getContext().flags.get(flagName) === true;
+}
+function getFeatureValue(flagName, defaultValue) {
+  const value = getContext().flags.get(flagName);
+  return value !== void 0 ? value : defaultValue;
+}
+function getFeatureFlags() {
+  return getContext().flags;
+}
+function tryGetFeatureValue(flagName) {
   const ctx = getStorage().getStore();
+  return ctx?.flags.get(flagName);
+}
+function hasFeatureFlagsContext() {
+  return getStorage().getStore() !== void 0;
+}
+function runWithFeatureFlags(flags, fn) {
+  const frozenContext = Object.freeze({ flags });
+  return getStorage().run(frozenContext, fn);
+}
+function withFeatureFlags(resolvedFlags, fn) {
+  return runWithFeatureFlags(resolvedFlags, fn);
+}
+
+// src/runtime/context/schema-context.ts
+var browserStub2 = {
+  getStore: () => void 0,
+  run: (_store, callback) => callback()
+};
+var AsyncLocalStorageClass2 = null;
+if (typeof process !== "undefined" && process.versions?.node) {
+  try {
+    if (typeof __require !== "undefined") {
+      const asyncHooks = __require("async_hooks");
+      AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+    }
+  } catch {
+    try {
+      const dynamicRequire = new Function(
+        "m",
+        'return typeof require!=="undefined"?require(m):null'
+      );
+      const asyncHooks = dynamicRequire("node:async_hooks");
+      if (asyncHooks) {
+        AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+      }
+    } catch {
+    }
+  }
+}
+var storageInstance2 = null;
+function getStorage2() {
+  if (storageInstance2 !== null) {
+    return storageInstance2;
+  }
+  if (AsyncLocalStorageClass2) {
+    storageInstance2 = new AsyncLocalStorageClass2();
+    return storageInstance2;
+  }
+  storageInstance2 = browserStub2;
+  return storageInstance2;
+}
+function getSchemaFromContext(objectId) {
+  const ctx = getStorage2().getStore();
   return ctx?.objectsById.get(objectId);
 }
 function getSchemaByNameFromContext(objectName) {
-  const ctx = getStorage().getStore();
+  const ctx = getStorage2().getStore();
   return ctx?.objectsByName.get(objectName);
 }
 function hasSchemaContext() {
-  return getStorage().getStore() !== void 0;
+  return getStorage2().getStore() !== void 0;
 }
 function getSchemaContext() {
-  return getStorage().getStore();
+  return getStorage2().getStore();
 }
 function addSchemaToContext(schema) {
-  const ctx = getStorage().getStore();
+  const ctx = getStorage2().getStore();
   if (!ctx) {
     return;
   }
@@ -618,10 +704,10 @@ function buildSchemaContext(schemas) {
 }
 function runWithSchemaContext(schemas, fn) {
   const context = buildSchemaContext(schemas);
-  return getStorage().run(context, fn);
+  return getStorage2().run(context, fn);
 }
 function runWithMergedSchemaContext(schemas, fn) {
-  const existing = getStorage().getStore();
+  const existing = getStorage2().getStore();
   const objectsById = new Map(existing?.objectsById);
   const objectsByName = new Map(existing?.objectsByName);
   for (const schema of schemas) {
@@ -634,20 +720,20 @@ function runWithMergedSchemaContext(schemas, fn) {
     objectsById,
     objectsByName
   };
-  return getStorage().run(context, fn);
+  return getStorage2().run(context, fn);
 }
 
 // src/runtime/context/tenant-context.ts
-var browserStub2 = {
+var browserStub3 = {
   getStore: () => void 0,
   run: (_store, callback) => callback()
 };
-var AsyncLocalStorageClass2 = null;
+var AsyncLocalStorageClass3 = null;
 if (typeof process !== "undefined" && process.versions?.node) {
   try {
     if (typeof __require !== "undefined") {
       const asyncHooks = __require("async_hooks");
-      AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+      AsyncLocalStorageClass3 = asyncHooks.AsyncLocalStorage;
     }
   } catch {
     try {
@@ -657,43 +743,43 @@ if (typeof process !== "undefined" && process.versions?.node) {
       );
       const asyncHooks = dynamicRequire("node:async_hooks");
       if (asyncHooks) {
-        AsyncLocalStorageClass2 = asyncHooks.AsyncLocalStorage;
+        AsyncLocalStorageClass3 = asyncHooks.AsyncLocalStorage;
       }
     } catch {
     }
   }
 }
-var storageInstance2 = null;
-function getStorage2() {
-  if (storageInstance2 !== null) {
-    return storageInstance2;
+var storageInstance3 = null;
+function getStorage3() {
+  if (storageInstance3 !== null) {
+    return storageInstance3;
   }
-  if (AsyncLocalStorageClass2) {
-    storageInstance2 = new AsyncLocalStorageClass2();
-    return storageInstance2;
+  if (AsyncLocalStorageClass3) {
+    storageInstance3 = new AsyncLocalStorageClass3();
+    return storageInstance3;
   }
-  storageInstance2 = browserStub2;
-  return storageInstance2;
+  storageInstance3 = browserStub3;
+  return storageInstance3;
 }
-function getContext() {
-  const ctx = getStorage2().getStore();
+function getContext2() {
+  const ctx = getStorage3().getStore();
   if (!ctx) {
     throw new TenantContextError();
   }
   return ctx;
 }
 function getTenantId() {
-  return getContext().tenantId;
+  return getContext2().tenantId;
 }
 function getUserId() {
-  return getContext().userId;
+  return getContext2().userId;
 }
 function hasContext() {
-  return getStorage2().getStore() !== void 0;
+  return getStorage3().getStore() !== void 0;
 }
 function runWithContext(context, fn) {
   const frozenContext = Object.freeze({ ...context });
-  return getStorage2().run(frozenContext, fn);
+  return getStorage3().run(frozenContext, fn);
 }
 function withTenantContext(tenantId, fn, userId) {
   return runWithContext({ tenantId, userId }, fn);
@@ -1261,12 +1347,6 @@ function or(...rules) {
 function inValues(field, values) {
   return { field, operator: "in", value: values };
 }
-function isEmpty(field) {
-  return { field, operator: "isEmpty", value: null };
-}
-function isNotEmpty(field) {
-  return { field, operator: "isNotEmpty", value: null };
-}
 
 // src/types/workflows/definition.ts
 function isWorkflowDefinition(obj) {
@@ -1376,16 +1456,6 @@ function setContextValue(context, path, value) {
   }
   current[parts[parts.length - 1]] = value;
 }
-function mergeFormToSlot(context, nodeId, slotId) {
-  const formData = context.forms[nodeId];
-  if (!formData) {
-    return;
-  }
-  if (!context.slots[slotId]) {
-    context.slots[slotId] = {};
-  }
-  Object.assign(context.slots[slotId], formData);
-}
 
 // src/types/workflows/theme.ts
 var DEFAULT_THEME = {
@@ -1739,9 +1809,9 @@ function compareValues(actual, operator, expected) {
       return typeof actual === "string" && typeof expected === "string" ? actual.endsWith(expected) : false;
     // Presence
     case "isEmpty":
-      return isEmpty2(actual);
+      return isEmptyValue(actual);
     case "isNotEmpty":
-      return !isEmpty2(actual);
+      return !isEmptyValue(actual);
     // Set membership
     case "in":
       if (Array.isArray(expected)) {
@@ -1757,7 +1827,7 @@ function compareValues(actual, operator, expected) {
       return false;
   }
 }
-function isEmpty2(value) {
+function isEmptyValue(value) {
   if (value === null || value === void 0) {
     return true;
   }
@@ -1767,7 +1837,7 @@ function isEmpty2(value) {
   if (Array.isArray(value) && value.length === 0) {
     return true;
   }
-  if (typeof value === "object" && Object.keys(value).length === 0) {
+  if (typeof value === "object" && isEmpty(value)) {
     return true;
   }
   return false;
@@ -2012,7 +2082,7 @@ var DocumentExecutor = class {
   validateSlotReferences(node, workflowSlots) {
     const errors = [];
     if (node.targetSlotIds && node.targetSlotIds.length > 0) {
-      const slotIdSet = new Set(workflowSlots.map((s) => s.id));
+      const slotIdSet = workflowSlots.reduce((set, s) => set.add(s.id), /* @__PURE__ */ new Set());
       for (const slotId of node.targetSlotIds) {
         if (!slotIdSet.has(slotId)) {
           errors.push(
@@ -2048,24 +2118,25 @@ var FormExecutor = class {
   }
   execute(node, context) {
     const { input } = context;
-    if (!input || Object.keys(input).length === 0) {
+    if (isEmpty(input)) {
       const requiredParticipationId = node.participantId ?? void 0;
       return wait(`Waiting for form submission: ${node.label}`, {
         requiredParticipationId
       });
     }
+    const formInput = input;
     const slotIds = this.extractSlotIds(node);
     if (slotIds.size === 0) {
       return error("MISSING_FIELDS", "FormNode must have fields or rows with slot references");
     }
     const contextUpdates = {
       forms: {
-        [node.id]: input
+        [node.id]: formInput
       },
       slots: {}
     };
     for (const slotId of slotIds) {
-      const slotInput = input[slotId] ?? {};
+      const slotInput = formInput[slotId] ?? {};
       if (!contextUpdates.slots) {
         contextUpdates.slots = {};
       }
@@ -2093,9 +2164,9 @@ var FormExecutor = class {
   }
   canExecute(node, context) {
     if (node.participantId && context.executorId) {
-      return context.input !== void 0 && Object.keys(context.input).length > 0;
+      return hasProperties(context.input);
     }
-    return context.input !== void 0 && Object.keys(context.input).length > 0;
+    return hasProperties(context.input);
   }
   validate(node) {
     const errors = [];
@@ -3387,9 +3458,6 @@ var ConcurrentModificationError = class extends SchemaError {
     );
   }
 };
-function isConcurrentModificationError(error2) {
-  return error2 instanceof ConcurrentModificationError;
-}
 
 // src/format.ts
 import { getCountryByIso3 } from "@stndrds/constants";
@@ -4000,6 +4068,7 @@ function createEmptyStores() {
     files: /* @__PURE__ */ new Map(),
     objectRecords: /* @__PURE__ */ new Map(),
     views: /* @__PURE__ */ new Map(),
+    viewOverlays: /* @__PURE__ */ new Map(),
     roles: /* @__PURE__ */ new Map(),
     permissions: /* @__PURE__ */ new Map(),
     userRoles: /* @__PURE__ */ new Map(),
@@ -4217,7 +4286,8 @@ function createMockPermissionsRepository(stores) {
     getUserRoles(userProfileId) {
       const tenantId = getTenantId();
       const roleIds = Array.from(stores.userRoles.values()).filter((ur) => ur.userProfileId === userProfileId && ur.tenantId === tenantId).map((ur) => ur.roleId);
-      const roles = Array.from(stores.roles.values()).filter((r) => roleIds.includes(r.id));
+      const roleIdsSet = new Set(roleIds);
+      const roles = Array.from(stores.roles.values()).filter((r) => roleIdsSet.has(r.id));
       return Promise.resolve(roles);
     },
     assignRole(input) {
@@ -4297,32 +4367,38 @@ function createMockViewsRepository(stores) {
         ) ?? null
       );
     },
-    findByObjectName(objectName) {
+    findByNameAndType(objectName, viewName, type) {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.views.values()).find(
+          (v) => v.tenantId === tenantId && v.objectName === objectName && v.name === viewName && v.type === type
+        ) ?? null
+      );
+    },
+    findByObjectName(objectName, type) {
       const tenantId = getTenantId();
       return Promise.resolve(
         Array.from(stores.views.values()).filter(
-          (v) => v.tenantId === tenantId && v.objectName === objectName
+          (v) => v.tenantId === tenantId && v.objectName === objectName && (type === void 0 || v.type === type)
         )
       );
     },
-    findAllForTenant() {
+    findAllForTenant(type) {
       const tenantId = getTenantId();
       return Promise.resolve(
-        Array.from(stores.views.values()).filter((v) => v.tenantId === tenantId)
+        Array.from(stores.views.values()).filter(
+          (v) => v.tenantId === tenantId && (type === void 0 || v.type === type)
+        )
       );
     },
-    findSystemByName(objectName, viewName) {
+    findDefault(objectName, type) {
+      const tenantId = getTenantId();
       return Promise.resolve(
         Array.from(stores.views.values()).find(
-          (v) => v.objectName === objectName && v.name === viewName && v.system
+          (v) => v.tenantId === tenantId && v.objectName === objectName && v.type === type && v.default === true
         ) ?? null
       );
     },
-    findSystemByObjectName(objectName) {
-      return Promise.resolve(
-        Array.from(stores.views.values()).filter((v) => v.objectName === objectName && v.system)
-      );
-    },
     create(data) {
       const tenantId = getTenantId();
       const id = generateId();
@@ -4331,13 +4407,13 @@ function createMockViewsRepository(stores) {
         id,
         tenantId,
         objectName: data.objectName,
+        type: data.type,
         name: data.name,
         label: data.label,
         description: data.description,
         icon: data.icon,
-        tabs: data.tabs,
+        config: data.config,
         default: data.default ?? false,
-        system: data.system ?? false,
         metadata: data.metadata,
         createdAt: now,
         updatedAt: now
@@ -4362,10 +4438,11 @@ function createMockViewsRepository(stores) {
       stores.views.delete(id);
       return Promise.resolve();
     },
-    deleteNotIn(objectName, keepViewNames) {
+    deleteNotIn(objectName, type, keepViewNames) {
+      const tenantId = getTenantId();
       let deleted = 0;
       for (const [id, view2] of stores.views.entries()) {
-        if (view2.objectName === objectName && view2.system && !keepViewNames.includes(view2.name)) {
+        if (view2.tenantId === tenantId && view2.objectName === objectName && view2.type === type && !keepViewNames.includes(view2.name)) {
           stores.views.delete(id);
           deleted++;
         }
@@ -4373,18 +4450,151 @@ function createMockViewsRepository(stores) {
       return Promise.resolve(deleted);
     },
     async upsert(data) {
-      const existing = data.system ? await this.findSystemByName(data.objectName, data.name) : await this.findByName(data.objectName, data.name);
+      const existing = await this.findByNameAndType(data.objectName, data.name, data.type);
       if (existing) {
         return this.update(existing.id, {
           label: data.label,
           description: data.description,
           icon: data.icon,
-          tabs: data.tabs,
+          config: data.config,
           default: data.default,
           metadata: data.metadata
         });
       }
       return this.create(data);
+    },
+    async exists(objectName, viewName, type) {
+      const existing = await this.findByNameAndType(objectName, viewName, type);
+      return existing !== null;
+    }
+  };
+}
+function createMockViewOverlaysRepository(stores) {
+  return {
+    findById(id) {
+      return Promise.resolve(stores.viewOverlays.get(id) ?? null);
+    },
+    findByViewAndUser(viewId, userId) {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.viewOverlays.values()).find(
+          (o) => o.tenantId === tenantId && o.viewId === viewId && o.userId === userId
+        ) ?? null
+      );
+    },
+    findByUser(userId) {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.viewOverlays.values()).filter(
+          (o) => o.tenantId === tenantId && o.userId === userId
+        )
+      );
+    },
+    findByView(viewId) {
+      const tenantId = getTenantId();
+      return Promise.resolve(
+        Array.from(stores.viewOverlays.values()).filter(
+          (o) => o.tenantId === tenantId && o.viewId === viewId
+        )
+      );
+    },
+    async findUserDefault(userId, objectName, type) {
+      const tenantId = getTenantId();
+      const views = Array.from(stores.views.values()).filter(
+        (v) => v.tenantId === tenantId && v.objectName === objectName && v.type === type
+      );
+      const viewIds = views.reduce((set, v) => set.add(v.id), /* @__PURE__ */ new Set());
+      return Promise.resolve(
+        Array.from(stores.viewOverlays.values()).find(
+          (o) => o.tenantId === tenantId && o.userId === userId && o.isUserDefault === true && viewIds.has(o.viewId)
+        ) ?? null
+      );
+    },
+    create(data) {
+      const tenantId = getTenantId();
+      const id = generateId();
+      const now = /* @__PURE__ */ new Date();
+      const overlay = {
+        id,
+        tenantId,
+        viewId: data.viewId,
+        userId: data.userId,
+        configOverrides: data.configOverrides,
+        isUserDefault: data.isUserDefault,
+        createdAt: now,
+        updatedAt: now
+      };
+      stores.viewOverlays.set(id, overlay);
+      return Promise.resolve(overlay);
+    },
+    update(id, data) {
+      const overlay = stores.viewOverlays.get(id);
+      if (!overlay) {
+        return Promise.reject(new Error(`ViewOverlay not found: ${id}`));
+      }
+      const updated = {
+        ...overlay,
+        ...data,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      stores.viewOverlays.set(id, updated);
+      return Promise.resolve(updated);
+    },
+    delete(id) {
+      stores.viewOverlays.delete(id);
+      return Promise.resolve();
+    },
+    async deleteByViewAndUser(viewId, userId) {
+      const overlay = await this.findByViewAndUser(viewId, userId);
+      if (overlay) {
+        stores.viewOverlays.delete(overlay.id);
+      }
+    },
+    deleteByView(viewId) {
+      const tenantId = getTenantId();
+      let deleted = 0;
+      for (const [id, overlay] of stores.viewOverlays.entries()) {
+        if (overlay.tenantId === tenantId && overlay.viewId === viewId) {
+          stores.viewOverlays.delete(id);
+          deleted++;
+        }
+      }
+      return Promise.resolve(deleted);
+    },
+    migrateViewId(fromViewId, toViewId) {
+      const tenantId = getTenantId();
+      let migrated = 0;
+      for (const overlay of stores.viewOverlays.values()) {
+        if (overlay.tenantId === tenantId && overlay.viewId === fromViewId) {
+          overlay.viewId = toViewId;
+          overlay.updatedAt = /* @__PURE__ */ new Date();
+          migrated++;
+        }
+      }
+      return Promise.resolve(migrated);
+    },
+    async upsert(data) {
+      const existing = await this.findByViewAndUser(data.viewId, data.userId);
+      if (existing) {
+        return this.update(existing.id, {
+          configOverrides: data.configOverrides,
+          isUserDefault: data.isUserDefault
+        });
+      }
+      return this.create(data);
+    },
+    async clearUserDefault(userId, objectName, type) {
+      const tenantId = getTenantId();
+      const views = Array.from(stores.views.values()).filter(
+        (v) => v.tenantId === tenantId && v.objectName === objectName && v.type === type
+      );
+      const viewIds = views.reduce((set, v) => set.add(v.id), /* @__PURE__ */ new Set());
+      for (const overlay of stores.viewOverlays.values()) {
+        if (overlay.tenantId === tenantId && overlay.userId === userId && overlay.isUserDefault === true && viewIds.has(overlay.viewId)) {
+          overlay.isUserDefault = false;
+          overlay.updatedAt = /* @__PURE__ */ new Date();
+        }
+      }
     }
   };
 }
@@ -4774,6 +4984,7 @@ function createMockAdapter() {
     files: createMockFilesRepository(stores),
     objectRecords: createMockObjectRecordsRepository(stores),
     views: createMockViewsRepository(stores),
+    viewOverlays: createMockViewOverlaysRepository(stores),
     permissions: createMockPermissionsRepository(stores),
     workflows: createMockWorkflowsRepository(stores),
     workflowInstances: createMockWorkflowInstancesRepository(stores),
@@ -4796,6 +5007,7 @@ function createMockAdapter() {
       stores.files.clear();
       stores.objectRecords.clear();
       stores.views.clear();
+      stores.viewOverlays.clear();
       stores.roles.clear();
       stores.permissions.clear();
       stores.userRoles.clear();
@@ -5339,6 +5551,32 @@ var BaseAttributeBuilder = class {
     this.attr.metadata = value;
     return this;
   }
+  /**
+   * Add a feature gate to conditionally show/hide/disable this attribute.
+   *
+   * @param flagName - Name of the feature flag to check
+   * @param options - Optional configuration for expected value and fallback behavior
+   *
+   * @example Hide attribute when flag is disabled
+   * ```typescript
+   * text({ name: "aiSummary", label: "AI Summary" })
+   *   .featureGate("ai-features")
+   * ```
+   *
+   * @example Disable attribute when tier is not enterprise
+   * ```typescript
+   * text({ name: "advancedField", label: "Advanced Field" })
+   *   .featureGate("tier", { expectedValue: "enterprise", fallback: "disable" })
+   * ```
+   */
+  featureGate(flagName, options) {
+    this.attr.featureGate = {
+      flag: flagName,
+      expectedValue: options?.expectedValue,
+      fallback: options?.fallback
+    };
+    return this;
+  }
   build() {
     return this.attr;
   }
@@ -6261,6 +6499,7 @@ function object(config) {
 }
 
 // src/builders/view-builder.ts
+import { randomUUID } from "crypto";
 import { z as z3 } from "zod";
 var GroupBuilder = class {
   constructor(id, label) {
@@ -6411,7 +6650,7 @@ var BaseTableTabConfig = class {
     return new TabBuilder(this.view, name, label);
   }
   /**
-   * Finish this tab and return to ViewBuilder
+   * Finish this tab and return to DetailViewBuilder
    */
   done() {
     this.finalize();
@@ -6477,7 +6716,7 @@ var CustomTabConfig = class {
     return new TabBuilder(this.view, name, label);
   }
   /**
-   * Finish this tab and return to ViewBuilder
+   * Finish this tab and return to DetailViewBuilder
    */
   done() {
     this.view._addTab(this.tabData);
@@ -6519,7 +6758,7 @@ var NotesTabConfig = class {
     return new TabBuilder(this.view, name, label);
   }
   /**
-   * Finish this tab and return to ViewBuilder
+   * Finish this tab and return to DetailViewBuilder
    */
   done() {
     this.view._addTab(this.tabData);
@@ -6554,7 +6793,7 @@ var ActivityTabConfig = class {
     return new TabBuilder(this.view, name, label);
   }
   /**
-   * Finish this tab and return to ViewBuilder
+   * Finish this tab and return to DetailViewBuilder
    */
   done() {
     this.view._addTab(this.tabData);
@@ -6617,7 +6856,7 @@ var FlowsTabConfig = class {
     return new TabBuilder(this.view, name, label);
   }
   /**
-   * Finish this tab and return to ViewBuilder
+   * Finish this tab and return to DetailViewBuilder
    */
   done() {
     this.view._addTab(this.tabData);
@@ -6688,7 +6927,7 @@ var DocumentsTabConfig = class {
     return new TabBuilder(this.view, name, label);
   }
   /**
-   * Finish this tab and return to ViewBuilder
+   * Finish this tab and return to DetailViewBuilder
    */
   done() {
     this.view._addTab(this.tabData);
@@ -6726,13 +6965,6 @@ var TabBuilder = class {
     this.base.order = value;
     return this;
   }
-  /**
-   * Mark as system tab (protected)
-   */
-  system() {
-    this.base.system = true;
-    return this;
-  }
   // ─────────────────────────────────────────────────────────────────────────
   // TYPE DISCRIMINATORS
   // ─────────────────────────────────────────────────────────────────────────
@@ -6812,13 +7044,15 @@ var TabBuilder = class {
     return new DocumentsTabConfig(this.view, this.base);
   }
 };
-var ViewBuilder = class {
+var DetailViewBuilder = class {
   constructor(name, label) {
-    this.data = { tabs: [] };
-    this.validated = false;
     this.validateName(name);
-    this.data.name = name;
-    this.data.label = label;
+    this.data = {
+      name,
+      label,
+      layout: "page",
+      tabs: []
+    };
   }
   /**
    * Set view description
@@ -6843,19 +7077,12 @@ var ViewBuilder = class {
     return this;
   }
   /**
-   * Mark as default view for the object (within its layout)
+   * Mark as default view for the object
    */
   default() {
     this.data.default = true;
     return this;
   }
-  /**
-   * Mark as system view (protected, defined by developer)
-   */
-  system() {
-    this.data.system = true;
-    return this;
-  }
   /**
    * Set the layout mode for the view
    * @param value - "page" for full tabs, "modal" for single form
@@ -6890,14 +7117,14 @@ var ViewBuilder = class {
    * Add a pre-built tab
    */
   addTab(tab) {
-    this.data.tabs?.push(tab);
+    this.data.tabs.push(tab);
     return this;
   }
   /**
    * @internal Used by TabBuilder to add tabs
    */
   _addTab(tab) {
-    this.data.tabs?.push(tab);
+    this.data.tabs.push(tab);
     return this;
   }
   /**
@@ -6905,28 +7132,41 @@ var ViewBuilder = class {
    */
   build() {
     if (!this.data.object) {
-      throw new Error("[ViewBuilder] for() is required - specify the target object");
+      throw new Error("[DetailViewBuilder] for() is required - specify the target object");
     }
-    if (!this.data.tabs || this.data.tabs.length === 0) {
-      throw new Error("[ViewBuilder] At least one tab is required");
+    if (this.data.tabs.length === 0) {
+      throw new Error("[DetailViewBuilder] At least one tab is required");
     }
     const tabNames = /* @__PURE__ */ new Set();
     for (const tab of this.data.tabs) {
       if (tabNames.has(tab.name)) {
-        throw new Error(`[ViewBuilder] Duplicate tab name "${tab.name}"`);
+        throw new Error(`[DetailViewBuilder] Duplicate tab name "${tab.name}"`);
       }
       tabNames.add(tab.name);
     }
     if (this.data.layout === "modal") {
       if (this.data.tabs.length !== 1) {
-        throw new Error("[ViewBuilder] Modal views must have exactly one tab");
+        throw new Error("[DetailViewBuilder] Modal views must have exactly one tab");
       }
       if (this.data.tabs[0].type !== "form") {
-        throw new Error("[ViewBuilder] Modal views must have a form tab");
+        throw new Error("[DetailViewBuilder] Modal views must have a form tab");
       }
     }
-    this.validated = true;
-    return this.data;
+    const config = {
+      layout: this.data.layout,
+      tabs: this.data.tabs
+    };
+    return {
+      name: this.data.name,
+      label: this.data.label,
+      description: this.data.description,
+      icon: this.data.icon,
+      object: this.data.object,
+      type: "detail",
+      config,
+      default: this.data.default,
+      metadata: this.data.metadata
+    };
   }
   /**
    * Validate view name format (kebab-case)
@@ -6939,24 +7179,295 @@ var ViewBuilder = class {
       viewNameSchema.parse(name);
     } catch (error2) {
       if (error2 instanceof z3.ZodError) {
-        throw new Error(`[ViewBuilder] ${error2.issues[0].message}`);
+        throw new Error(`[DetailViewBuilder] ${error2.issues[0].message}`);
       }
       throw error2;
     }
   }
 };
-function view(name, label) {
-  return new ViewBuilder(name, label);
+var ViewBuilder = DetailViewBuilder;
+function detailView(name, label) {
+  return new DetailViewBuilder(name, label);
 }
-function group(id, label) {
-  return new GroupBuilder(id, label);
+function view(name, label) {
+  return new DetailViewBuilder(name, label);
 }
-
-// src/builders/workflow-builder.ts
-import { z as z4 } from "zod";
-var WorkflowFormRowBuilder = class {
-  /** @internal */
-  constructor(formBuilder, rowId, order) {
+var ListViewBuilder = class {
+  constructor(name, label) {
+    this.validateName(name);
+    this.data = {
+      name,
+      label,
+      layout: "table",
+      columns: [],
+      tabs: []
+    };
+  }
+  /**
+   * Set view description
+   */
+  description(value) {
+    this.data.description = value;
+    return this;
+  }
+  /**
+   * Set view icon
+   */
+  icon(value) {
+    this.data.icon = value;
+    return this;
+  }
+  /**
+   * Associate view with an object
+   * @param objectName - Object name (kebab-case)
+   */
+  for(objectName) {
+    this.data.object = objectName;
+    return this;
+  }
+  /**
+   * Mark as default view for the object
+   */
+  default() {
+    this.data.default = true;
+    return this;
+  }
+  /**
+   * Set metadata
+   */
+  metadata(value) {
+    this.data.metadata = value;
+    return this;
+  }
+  /**
+   * Set the layout to table (default)
+   */
+  table() {
+    this.data.layout = "table";
+    return this;
+  }
+  /**
+   * Set the layout to kanban and specify the grouping attribute
+   * @param groupByAttribute - Attribute to group by (must be a select/status type)
+   */
+  kanban(groupByAttribute) {
+    this.data.layout = "kanban";
+    this.data.groupByAttribute = groupByAttribute;
+    return this;
+  }
+  /**
+   * Set columns to display
+   * @example .columns("name", "email", "status", "createdAt")
+   */
+  columns(...names) {
+    this.data.columns = names;
+    return this;
+  }
+  /**
+   * Set width for a specific column in pixels
+   * @example .columnWidth("email", 200)
+   */
+  columnWidth(columnName, width) {
+    if (!this.data.columnSizing) {
+      this.data.columnSizing = {};
+    }
+    this.data.columnSizing[columnName] = width;
+    return this;
+  }
+  /**
+   * Set widths for multiple columns
+   * @example .columnWidths({ email: 200, name: 300, status: 100 })
+   */
+  columnWidths(widths) {
+    this.data.columnSizing = { ...this.data.columnSizing, ...widths };
+    return this;
+  }
+  /**
+   * Set default filters
+   * @example .filter({ combinator: "and", rules: [{ attribute: "status", operator: "is", value: "active" }] })
+   */
+  filter(filters) {
+    this.data.defaultFilters = filters;
+    return this;
+  }
+  /**
+   * Add a single sort rule
+   * @example .sort("lastName", "asc")
+   */
+  sort(attribute, direction = "asc") {
+    if (!this.data.defaultSorts) {
+      this.data.defaultSorts = [];
+    }
+    this.data.defaultSorts.push({ attribute, direction });
+    return this;
+  }
+  /**
+   * Set multiple sort rules
+   * @example .sorts([{ attribute: "lastName", direction: "asc" }, { attribute: "firstName", direction: "asc" }])
+   */
+  sorts(rules) {
+    this.data.defaultSorts = rules;
+    return this;
+  }
+  /**
+   * Add an internal tab (filter preset)
+   * Returns a TabConfigBuilder for chaining tab configuration
+   * @example
+   * ```typescript
+   * .tab("all", "All Contacts").icon("users").default()
+   * .tab("active", "Active").icon("check").filter({ ... })
+   * ```
+   */
+  tab(id, label) {
+    return new ListViewTabConfigBuilder(this, id, label);
+  }
+  /**
+   * @internal Used by ListViewTabConfigBuilder to add tabs
+   */
+  _addTab(tab) {
+    this.data.tabs.push(tab);
+    return this;
+  }
+  /**
+   * Build the final list view definition
+   */
+  build() {
+    if (!this.data.object) {
+      throw new Error("[ListViewBuilder] for() is required - specify the target object");
+    }
+    if (this.data.columns.length === 0) {
+      throw new Error("[ListViewBuilder] columns() is required - specify at least one column");
+    }
+    if (this.data.layout === "kanban" && !this.data.groupByAttribute) {
+      throw new Error(
+        "[ListViewBuilder] kanban() requires a groupByAttribute - specify the attribute to group by"
+      );
+    }
+    const tabIds = /* @__PURE__ */ new Set();
+    for (const tab of this.data.tabs) {
+      if (tabIds.has(tab.id)) {
+        throw new Error(`[ListViewBuilder] Duplicate tab id "${tab.id}"`);
+      }
+      tabIds.add(tab.id);
+    }
+    const defaultTabs = this.data.tabs.filter((t) => t.default);
+    if (defaultTabs.length > 1) {
+      throw new Error("[ListViewBuilder] Only one tab can be marked as default");
+    }
+    const config = {
+      layout: this.data.layout,
+      columns: this.data.columns,
+      columnSizing: this.data.columnSizing,
+      defaultFilters: this.data.defaultFilters ? {
+        id: randomUUID(),
+        combinator: this.data.defaultFilters.combinator,
+        rules: this.data.defaultFilters.rules
+      } : void 0,
+      defaultSorts: this.data.defaultSorts,
+      groupByAttribute: this.data.groupByAttribute,
+      tabs: this.data.tabs.length > 0 ? this.data.tabs.map((tab) => ({
+        id: tab.id,
+        label: tab.label,
+        icon: tab.icon,
+        filters: tab.filters ? {
+          id: randomUUID(),
+          combinator: tab.filters.combinator,
+          rules: tab.filters.rules
+        } : void 0,
+        default: tab.default
+      })) : void 0
+    };
+    return {
+      name: this.data.name,
+      label: this.data.label,
+      description: this.data.description,
+      icon: this.data.icon,
+      object: this.data.object,
+      type: "list",
+      config,
+      default: this.data.default,
+      metadata: this.data.metadata
+    };
+  }
+  /**
+   * Validate view name format (kebab-case)
+   */
+  validateName(name) {
+    const viewNameSchema = z3.string().min(1, "View name cannot be empty").max(63, "View name is too long (max 63 characters)").regex(/^[a-z][a-z0-9-]*$/, {
+      message: "Invalid view name format.\nName must be in kebab-case:\n  \u2705 Valid: 'default', 'list-view', 'active-contacts'\n  \u274C Invalid: 'Default', 'listView', 'list_view'"
+    });
+    try {
+      viewNameSchema.parse(name);
+    } catch (error2) {
+      if (error2 instanceof z3.ZodError) {
+        throw new Error(`[ListViewBuilder] ${error2.issues[0].message}`);
+      }
+      throw error2;
+    }
+  }
+};
+var ListViewTabConfigBuilder = class _ListViewTabConfigBuilder {
+  /** @internal */
+  constructor(view2, id, label) {
+    this.view = view2;
+    this.tabData = { id, label };
+  }
+  /**
+   * Set tab icon
+   */
+  icon(value) {
+    this.tabData.icon = value;
+    return this;
+  }
+  /**
+   * Set filters for this tab (filter preset)
+   * @example .filter({ combinator: "and", rules: [{ attribute: "status", operator: "is", value: "active" }] })
+   */
+  filter(filters) {
+    this.tabData.filters = filters;
+    return this;
+  }
+  /**
+   * Mark this tab as the default tab
+   */
+  default() {
+    this.tabData.default = true;
+    return this;
+  }
+  /**
+   * Continue building with a new tab
+   */
+  tab(id, label) {
+    this.view._addTab(this.tabData);
+    return new _ListViewTabConfigBuilder(this.view, id, label);
+  }
+  /**
+   * Finish this tab and return to ListViewBuilder
+   */
+  done() {
+    this.view._addTab(this.tabData);
+    return this.view;
+  }
+  /**
+   * Build the final view definition
+   */
+  build() {
+    this.view._addTab(this.tabData);
+    return this.view.build();
+  }
+};
+function listView(name, label) {
+  return new ListViewBuilder(name, label);
+}
+function group(id, label) {
+  return new GroupBuilder(id, label);
+}
+
+// src/builders/workflow-builder.ts
+import { z as z4 } from "zod";
+var WorkflowFormRowBuilder = class {
+  /** @internal */
+  constructor(formBuilder, rowId, order) {
     this.formBuilder = formBuilder;
     this.rowData = {
       id: rowId,
@@ -7373,13 +7884,13 @@ var WorkflowBuilder = class {
     if (!this.startNodeId) {
       throw new Error("[WorkflowBuilder] A start node is required. Use .start() to add one.");
     }
-    if (!this.data.nodes || Object.keys(this.data.nodes).length === 0) {
+    if (isEmpty(this.data.nodes)) {
       throw new Error("[WorkflowBuilder] At least one node is required.");
     }
     if (!this.data.slots || this.data.slots.length === 0) {
       throw new Error("[WorkflowBuilder] At least one slot is required. Use .slot() to add slots.");
     }
-    const hasEndNode = Object.values(this.data.nodes).some((n) => n.type === "end");
+    const hasEndNode = this.data.nodes ? Object.values(this.data.nodes).some((n) => n.type === "end") : false;
     if (!hasEndNode) {
       throw new Error(
         "[WorkflowBuilder] At least one end node is required. Use .end() to add one."
@@ -7410,7 +7921,7 @@ var WorkflowBuilder = class {
     }
   }
   validateSlotReferences() {
-    const slotIds = new Set(this.data.slots?.map((s) => s.id) ?? []);
+    const slotIds = this.data.slots?.reduce((set, s) => set.add(s.id), /* @__PURE__ */ new Set()) ?? /* @__PURE__ */ new Set();
     for (const node of Object.values(this.data.nodes ?? {})) {
       if (node.type === "form") {
         const referencedSlots = /* @__PURE__ */ new Set();
@@ -7492,6 +8003,30 @@ function workflow(name, label) {
   return new WorkflowBuilder(name, label);
 }
 
+// src/types/attribute-protection.ts
+var IDENTITY_PROPERTIES = ["name", "type"];
+var BEHAVIOR_PROPERTIES = [
+  "required",
+  "disabled",
+  "hidden",
+  "archived",
+  "deprecated",
+  "defaultValue",
+  "config",
+  "order",
+  "unique"
+];
+var PRESENTATION_PROPERTIES = ["label", "description", "placeholder", "icon"];
+function isIdentityProperty(property) {
+  return IDENTITY_PROPERTIES.includes(property);
+}
+function isBehaviorProperty(property) {
+  return BEHAVIOR_PROPERTIES.includes(property);
+}
+function isPresentationProperty(property) {
+  return PRESENTATION_PROPERTIES.includes(property);
+}
+
 // src/types/errors.ts
 var RecordReferencedError = class extends Error {
   constructor(recordId, references) {
@@ -7583,582 +8118,25 @@ var SYSTEM_ATTRIBUTES = {
     label: "Pi\xE8ces jointes",
     type: "document",
     required: false,
-    disabled: false,
-    // Editable via Documents tab
-    system: true,
-    hidden: true,
-    // Hidden from regular form views
-    multiple: true,
-    icon: "paperclip",
-    description: "Free-form document attachments"
-    // No templateId = all templates allowed
-  }
-};
-function getSystemAttributeList() {
-  return Object.values(SYSTEM_ATTRIBUTES);
-}
-function isSystemAttribute(name) {
-  return name in SYSTEM_ATTRIBUTES;
-}
-function isSystemAttributeObject(attr) {
-  return attr.system === true;
-}
-
-// src/validation/validators.ts
-import { z as z5 } from "zod";
-var regexPatternCache = /* @__PURE__ */ new Map();
-function getCachedRegex(pattern) {
-  let cached = regexPatternCache.get(pattern);
-  if (!cached) {
-    cached = new RegExp(pattern);
-    regexPatternCache.set(pattern, cached);
-  }
-  return cached;
-}
-var DEFAULT_VALIDATION_MESSAGES = {
-  required: (attr) => `${attr.label} is required`,
-  invalidType: (attr, expected) => `${attr.label} must be a ${expected}`,
-  minLength: (attr, min) => `${attr.label} must be at least ${min} characters`,
-  maxLength: (attr, max) => `${attr.label} must be at most ${max} characters`,
-  invalidPattern: (attr) => `${attr.label} format is invalid`,
-  minValue: (attr, min) => `${attr.label} must be at least ${min}`,
-  maxValue: (attr, max) => `${attr.label} must be at most ${max}`,
-  mustBeInteger: (attr) => `${attr.label} must be an integer`,
-  invalidDate: (attr) => `${attr.label} must be a valid date`,
-  invalidOption: (attr, options) => `${attr.label} must be one of: ${options.join(", ")}`,
-  invalidId: (attr) => `${attr.label} must be a valid ID`,
-  minItems: (attr, min) => `${attr.label} must have at least ${min} item${min > 1 ? "s" : ""}`,
-  maxItems: (attr, max) => `${attr.label} must have at most ${max} item${max > 1 ? "s" : ""}`,
-  invalidRichtext: (attr) => `${attr.label} must be valid rich text content`,
-  invalidPhone: (attr) => `${attr.label} must be a valid phone number`,
-  invalidCurrency: (attr) => `${attr.label} must be a valid currency value`,
-  invalidLocation: (attr) => `${attr.label} must be a valid location`
-};
-var baseConfigSchema = z5.object({
-  disabled: z5.boolean().optional(),
-  placeholder: z5.string().optional(),
-  description: z5.string().optional(),
-  defaultValue: z5.unknown().optional(),
-  icon: z5.string().optional(),
-  order: z5.number().int().optional(),
-  hidden: z5.boolean().optional(),
-  archived: z5.boolean().optional(),
-  deprecated: z5.boolean().optional(),
-  metadata: z5.record(z5.string(), z5.unknown()).optional()
-});
-var optionSchema = z5.object({
-  id: z5.string().min(1),
-  label: z5.string().min(1),
-  value: z5.string().min(1),
-  color: z5.string().optional(),
-  icon: z5.string().optional(),
-  description: z5.string().optional(),
-  group: z5.enum(["idle", "in_progress", "finished"]).optional()
-});
-var optionsArraySchema = z5.array(optionSchema).min(1).refine(
-  (options) => {
-    const values = options.map((o) => o.value);
-    return new Set(values).size === values.length;
-  },
-  { message: "Duplicate option values are not allowed" }
-);
-var relationTargetSchema = z5.object({
-  object: z5.string().min(1),
-  displayTemplate: z5.string().optional(),
-  filter: z5.record(z5.string(), z5.unknown()).optional()
-});
-var textConfigSchema = baseConfigSchema.extend({
-  minLength: z5.number().int().min(0).optional(),
-  maxLength: z5.number().int().min(1).optional(),
-  pattern: z5.string().optional()
-});
-var textareaConfigSchema = baseConfigSchema;
-var richtextConfigSchema = baseConfigSchema.extend({
-  features: z5.array(
-    z5.enum(["headings", "bold", "italic", "lists", "links", "images", "codeBlocks", "tables"])
-  ).optional()
-});
-var numberConfigSchema = baseConfigSchema.extend({
-  min: z5.number().optional(),
-  max: z5.number().optional(),
-  unit: z5.enum(["integer", "decimal", "percentage"]).optional(),
-  decimals: z5.number().int().min(0).optional()
-});
-var checkboxConfigSchema = baseConfigSchema;
-var dateConfigSchema = baseConfigSchema.extend({
-  dateFormat: z5.enum(["short", "long", "full", "relative"]).optional(),
-  minDate: z5.string().optional(),
-  maxDate: z5.string().optional()
-});
-var phoneConfigSchema = baseConfigSchema.extend({
-  defaultCountryCode: z5.string().length(3).optional()
-});
-var currencyConfigSchema = baseConfigSchema.extend({
-  defaultCurrency: z5.string().length(3).optional(),
-  allowedCurrencies: z5.array(z5.string().length(3)).optional()
-});
-var statusConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var locationConfigSchema = baseConfigSchema.extend({
-  granularity: z5.enum(["full", "address", "city", "state", "country", "coordinates"]),
-  enableAutocomplete: z5.boolean().optional(),
-  enableMap: z5.boolean().optional(),
-  defaultCountry: z5.string().length(3).optional(),
-  allowedCountries: z5.array(z5.string().length(3)).optional(),
-  displayFormat: z5.enum(["single_line", "multi_line", "compact"]).optional()
-});
-var selectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var multiselectConfigSchema = baseConfigSchema.extend({
-  options: optionsArraySchema
-});
-var fileConfigSchema = baseConfigSchema.extend({
-  maxFiles: z5.number().int().min(1).optional(),
-  maxSize: z5.number().int().min(1).optional(),
-  allowedTypes: z5.array(z5.string()).optional(),
-  multiple: z5.boolean().optional()
-});
-var userConfigSchema = baseConfigSchema.extend({
-  allowedRoles: z5.array(z5.string()).optional(),
-  multiple: z5.boolean().optional()
-});
-var relationConfigSchema = baseConfigSchema.extend({
-  targets: z5.array(relationTargetSchema).min(1),
-  cardinality: z5.enum(["one", "many"]),
-  minItems: z5.number().int().min(0).optional(),
-  maxItems: z5.number().int().min(1).optional()
-});
-var ratingConfigSchema = baseConfigSchema.extend({
-  max: z5.number().int().min(1).optional(),
-  iconType: z5.enum(["star", "heart", "thumbs", "number"]).optional()
-});
-var formulaConfigSchema = baseConfigSchema.extend({
-  expression: z5.string().min(1),
-  returnType: z5.enum(["text", "number", "boolean", "date"]),
-  decimals: z5.number().int().min(0).max(10).optional(),
-  allowRelations: z5.boolean().optional()
-});
-var rollupConfigSchema = baseConfigSchema.extend({
-  relationAttribute: z5.string().min(1).optional(),
-  relationPath: z5.string().optional(),
-  targetAttribute: z5.string().min(1),
-  function: z5.enum([
-    // Numeric aggregates
-    "sum",
-    "avg",
-    // Date aggregates
-    "earliest",
-    "latest",
-    // Count (universal)
-    "count",
-    "countValues",
-    "countUniqueValues",
-    "countEmpty",
-    // Percent (universal)
-    "percentEmpty",
-    "percentNotEmpty",
-    // Lookup (universal)
-    "original"
-  ]),
-  decimals: z5.number().int().min(0).max(10).optional(),
-  targetAttributeType: z5.string().optional(),
-  targetAttributeOptions: z5.array(
-    z5.object({
-      id: z5.string(),
-      label: z5.string(),
-      value: z5.string(),
-      color: z5.string().optional(),
-      icon: z5.string().optional(),
-      description: z5.string().optional(),
-      group: z5.enum(["idle", "in_progress", "finished"]).optional()
-    })
-  ).optional()
-});
-var documentConfigSchema = baseConfigSchema.extend({
-  templateId: z5.string().optional(),
-  allowedTemplates: z5.array(z5.string()).optional(),
-  multiple: z5.boolean().optional(),
-  maxDocuments: z5.number().int().min(1).optional(),
-  autoProcess: z5.boolean().optional()
-});
-var attributeConfigSchemas = {
-  text: textConfigSchema,
-  textarea: textareaConfigSchema,
-  richtext: richtextConfigSchema,
-  number: numberConfigSchema,
-  checkbox: checkboxConfigSchema,
-  date: dateConfigSchema,
-  phone: phoneConfigSchema,
-  currency: currencyConfigSchema,
-  status: statusConfigSchema,
-  location: locationConfigSchema,
-  select: selectConfigSchema,
-  multiselect: multiselectConfigSchema,
-  file: fileConfigSchema,
-  user: userConfigSchema,
-  relation: relationConfigSchema,
-  rating: ratingConfigSchema,
-  formula: formulaConfigSchema,
-  rollup: rollupConfigSchema,
-  document: documentConfigSchema
-};
-function getAttributeConfigSchema(type) {
-  return attributeConfigSchemas[type];
-}
-function validateAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  const result = schema.safeParse(config);
-  if (result.success) {
-    return { success: true, data: result.data };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.map((err) => `${err.path.join(".")}: ${err.message}`)
-  };
-}
-function parseAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  return schema.strip().parse(config);
-}
-function safeParseAttributeConfig(type, config) {
-  const schema = getAttributeConfigSchema(type);
-  const result = schema.strip().safeParse(config);
-  return result.success ? result.data : void 0;
-}
-function createTextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  let schema = z5.string();
-  if (attr.minLength !== void 0) {
-    schema = schema.min(attr.minLength, messages.minLength(attr, attr.minLength));
-  }
-  if (attr.maxLength !== void 0) {
-    schema = schema.max(attr.maxLength, messages.maxLength(attr, attr.maxLength));
-  }
-  if (attr.pattern) {
-    schema = schema.regex(getCachedRegex(attr.pattern), messages.invalidPattern(attr));
-  }
-  return schema;
-}
-function createNumberValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  let schema = z5.number();
-  if (attr.min !== void 0) {
-    schema = schema.min(attr.min, messages.minValue(attr, attr.min));
-  }
-  if (attr.max !== void 0) {
-    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
-  }
-  if (attr.unit === "integer") {
-    schema = schema.int(messages.mustBeInteger(attr));
-  }
-  return schema;
-}
-function createCheckboxValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.boolean();
-}
-function createDateValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.coerce.date({ message: messages.invalidDate(attr) });
-}
-function createPhoneValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.object(
-    {
-      countryCode: z5.string().length(3),
-      phoneNumber: z5.string().min(1)
-    },
-    { message: messages.invalidPhone(attr) }
-  );
-}
-function createCurrencyValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.object(
-    {
-      code: z5.string().length(3),
-      value: z5.number().min(0)
-    },
-    { message: messages.invalidCurrency(attr) }
-  );
-}
-function createStatusValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  return z5.enum(validValues, {
-    message: messages.invalidOption(attr, validValues)
-  });
-}
-function createSelectValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  return z5.enum(validValues, {
-    message: messages.invalidOption(attr, validValues)
-  });
-}
-function createMultiselectValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validValues = attr.options.map((opt) => opt.value);
-  return z5.array(
-    z5.enum(validValues, {
-      message: messages.invalidOption(attr, validValues)
-    })
-  );
-}
-function createLocationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.object(
-    {
-      address: z5.string().optional(),
-      address2: z5.string().optional(),
-      city: z5.string().optional(),
-      state: z5.string().optional(),
-      postalCode: z5.string().optional(),
-      country: z5.string().length(3).optional(),
-      latitude: z5.number().optional(),
-      longitude: z5.number().optional()
-    },
-    { message: messages.invalidLocation(attr) }
-  );
-}
-function createFileValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  if (attr.multiple) {
-    let arraySchema = z5.array(uuidSchema);
-    if (attr.maxFiles) {
-      arraySchema = arraySchema.max(attr.maxFiles, messages.maxItems(attr, attr.maxFiles));
-    }
-    return arraySchema;
-  }
-  return uuidSchema;
-}
-function createUserValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  if (attr.multiple) {
-    return z5.array(uuidSchema);
-  }
-  return uuidSchema;
-}
-function createSingleRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  return z5.union([uuidSchema, z5.null()]);
-}
-function createMultiRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const uuidSchema = z5.uuid({
-    message: messages.invalidId(attr)
-  });
-  let arraySchema = z5.array(uuidSchema);
-  if (attr.minItems !== void 0) {
-    arraySchema = arraySchema.min(attr.minItems, messages.minItems(attr, attr.minItems));
-  }
-  if (attr.maxItems !== void 0) {
-    arraySchema = arraySchema.max(attr.maxItems, messages.maxItems(attr, attr.maxItems));
-  }
-  return arraySchema;
-}
-function createRelationValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  if (attr.cardinality === "many") {
-    return createMultiRelationValidator(attr, messages);
-  }
-  return createSingleRelationValidator(attr, messages);
-}
-function createRatingValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  let schema = z5.number().min(0);
-  if (attr.max !== void 0) {
-    schema = schema.max(attr.max, messages.maxValue(attr, attr.max));
-  }
-  return schema;
-}
-function createFormulaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.unknown();
-}
-function createRollupValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.unknown();
-}
-function createTextAreaValidator(_attr, _messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.string();
-}
-function createRichtextValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  return z5.string({
-    message: messages.invalidRichtext(attr)
-  });
-}
-function createAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  switch (attr.type) {
-    case "text":
-      return createTextValidator(attr, messages);
-    case "textarea":
-      return createTextAreaValidator(attr, messages);
-    case "richtext":
-      return createRichtextValidator(attr, messages);
-    case "number":
-      return createNumberValidator(attr, messages);
-    case "checkbox":
-      return createCheckboxValidator(attr, messages);
-    case "date":
-      return createDateValidator(attr, messages);
-    case "phone":
-      return createPhoneValidator(attr, messages);
-    case "currency":
-      return createCurrencyValidator(attr, messages);
-    case "status":
-      return createStatusValidator(attr, messages);
-    case "location":
-      return createLocationValidator(attr, messages);
-    case "select":
-      return createSelectValidator(attr, messages);
-    case "multiselect":
-      return createMultiselectValidator(attr, messages);
-    case "file":
-      return createFileValidator(attr, messages);
-    case "user":
-      return createUserValidator(attr, messages);
-    case "relation":
-      return createRelationValidator(attr, messages);
-    case "rating":
-      return createRatingValidator(attr, messages);
-    case "formula":
-      return createFormulaValidator(attr, messages);
-    case "rollup":
-      return createRollupValidator(attr, messages);
-    default:
-      return z5.unknown();
-  }
-}
-function isEmptyValue(value) {
-  if (value === null || value === void 0) return true;
-  if (typeof value === "string" && value.trim() === "") return true;
-  if (value instanceof Date) return false;
-  if (typeof value === "object" && !Array.isArray(value)) {
-    return Object.values(value).every(
-      (v) => v === null || v === void 0 || typeof v === "string" && v.trim() === ""
-    );
-  }
-  return false;
-}
-function withEmptyToNull(validator) {
-  return z5.preprocess((val) => isEmptyValue(val) ? null : val, validator.nullish());
-}
-function createFormAttributeValidator(attr, messages = DEFAULT_VALIDATION_MESSAGES) {
-  const validator = createAttributeValidator(attr, messages);
-  if (!attr.required) {
-    return withEmptyToNull(validator);
-  }
-  return validator;
-}
-function createObjectValidator(objectDef) {
-  const shape = {};
-  for (const attr of objectDef.attributes) {
-    const validator = createAttributeValidator(attr);
-    shape[attr.name] = attr.required ? validator : withEmptyToNull(validator);
-  }
-  return z5.object(shape).passthrough();
-}
-function validateAttribute(attr, value) {
-  const validator = createAttributeValidator(attr);
-  if (!attr.required && (value === void 0 || value === null)) {
-    return { success: true, data: { [attr.name]: value } };
-  }
-  const result = validator.safeParse(value);
-  if (result.success) {
-    return {
-      success: true,
-      data: { [attr.name]: result.data }
-    };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.map((err) => ({
-      path: [attr.name, ...err.path.map(String)],
-      message: err.message
-    }))
-  };
-}
-function validateObject(objectDef, data) {
-  const validator = createObjectValidator(objectDef);
-  const result = validator.safeParse(data);
-  if (result.success) {
-    return {
-      success: true,
-      data: result.data
-    };
-  }
-  return {
-    success: false,
-    errors: result.error.issues.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);
-    shape[attr.name] = withEmptyToNull(validator);
-  }
-  return z5.object(shape).passthrough();
-}
-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.issues.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);
-    }
+    disabled: false,
+    // Editable via Documents tab
+    system: true,
+    hidden: true,
+    // Hidden from regular form views
+    multiple: true,
+    icon: "paperclip",
+    description: "Free-form document attachments"
+    // No templateId = all templates allowed
   }
-  return missing;
+};
+function getSystemAttributeList() {
+  return Object.values(SYSTEM_ATTRIBUTES);
 }
-function isRecordComplete(objectDef, data) {
-  const missing = getMissingRequiredAttributes(objectDef, data);
-  if (missing.length > 0) {
-    return false;
-  }
-  const validation = validateObject(objectDef, data);
-  return validation.success;
+function isSystemAttribute(name) {
+  return name in SYSTEM_ATTRIBUTES;
 }
-function computeRecordStatus(objectDef, data) {
-  return isRecordComplete(objectDef, data) ? "complete" : "draft";
+function isSystemAttributeObject(attr) {
+  return attr.system === true;
 }
 
 // src/runtime/services/audit/helpers.ts
@@ -8321,7 +8299,8 @@ var ObjectSchemaService = class extends BaseService {
   }
   /**
    * Update an attribute.
-   * Can only update custom attributes (system=false).
+   * Custom attributes can be fully updated.
+   * System attributes can only have presentation properties modified (label, description, placeholder, icon).
    * Automatically uses tenant context from AsyncLocalStorage.
    *
    * @param attributeId - Attribute UUID
@@ -8333,20 +8312,34 @@ var ObjectSchemaService = class extends BaseService {
     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."
-      );
+    const requestedKeys = Object.keys(updates);
+    const identityChanges = requestedKeys.filter(
+      (k) => IDENTITY_PROPERTIES.includes(k)
+    );
+    if (identityChanges.length > 0) {
+      const actualChanges = identityChanges.filter((k) => {
+        const key = k;
+        return updates[key] !== void 0 && updates[key] !== dbAttr[key];
+      });
+      if (actualChanges.length > 0) {
+        throw new Error(
+          `Cannot modify identity properties: ${actualChanges.join(", ")}. These properties cannot be changed after creation.`
+        );
+      }
     }
-    if (updates.type && updates.type !== dbAttr.type) {
-      throw new Error(
-        "Attribute type cannot be changed after creation. Create a new attribute instead."
+    if (dbAttr.system) {
+      const behaviorChanges = requestedKeys.filter(
+        (k) => BEHAVIOR_PROPERTIES.includes(k)
       );
+      const actualBehaviorChanges = behaviorChanges.filter((k) => {
+        const key = k;
+        return updates[key] !== void 0;
+      });
+      if (actualBehaviorChanges.length > 0) {
+        throw new Error(
+          `Cannot modify behavior properties on system attribute "${dbAttr.name}": ${actualBehaviorChanges.join(", ")}. Only presentation properties (${PRESENTATION_PROPERTIES.join(", ")}) are editable.`
+        );
+      }
     }
     const mergedInput = {
       name: dbAttr.name,
@@ -9657,7 +9650,7 @@ async function preloadSchemas(records, schemaService) {
   if (records.length === 0) {
     return schemasByObjectId;
   }
-  const uniqueObjectIds = [...new Set(records.map((r) => r.objectId))];
+  const uniqueObjectIds = [...records.reduce((set, r) => set.add(r.objectId), /* @__PURE__ */ new Set())];
   await Promise.all(
     uniqueObjectIds.map(async (objId) => {
       const schema = await schemaService.getObjectSchema(objId);
@@ -10304,8 +10297,10 @@ var RelationService = class extends BaseService {
       const [attributeId, recordId] = c.split(":");
       return { compositeId: c, attributeId, recordId };
     });
-    const uniqueRecordIds = [...new Set(parsed.map((p) => p.recordId))];
-    const uniqueAttributeIds = [...new Set(parsed.map((p) => p.attributeId))];
+    const uniqueRecordIds = [...parsed.reduce((set, p) => set.add(p.recordId), /* @__PURE__ */ new Set())];
+    const uniqueAttributeIds = [
+      ...parsed.reduce((set, p) => set.add(p.attributeId), /* @__PURE__ */ new Set())
+    ];
     const records = await this.recordResolver.findByIds(uniqueRecordIds);
     if (records.length === 0) {
       return [];
@@ -10314,7 +10309,7 @@ var RelationService = class extends BaseService {
     const attributePromises = uniqueAttributeIds.map((id) => this.findAttributeById(id));
     const attributes = await Promise.all(attributePromises);
     const attributeMap = new Map(uniqueAttributeIds.map((id, i) => [id, attributes[i]]));
-    const uniqueObjectIds = [...new Set(records.map((r) => r.objectId))];
+    const uniqueObjectIds = [...records.reduce((set, r) => set.add(r.objectId), /* @__PURE__ */ new Set())];
     const schemaPromises = uniqueObjectIds.map((id) => this.schemaService.getObjectSchema(id));
     const schemas = await Promise.all(schemaPromises);
     const schemaMap = new Map(uniqueObjectIds.map((id, i) => [id, schemas[i]]));
@@ -10567,7 +10562,10 @@ var RollupService = class extends BaseService {
         return values.filter((v) => v != null && v !== "").length;
       case "countUniqueValues": {
         const nonEmpty = values.filter((v) => v != null && v !== "");
-        return new Set(nonEmpty.map((v) => JSON.stringify(v))).size;
+        return nonEmpty.reduce(
+          (set, v) => set.add(JSON.stringify(v)),
+          /* @__PURE__ */ new Set()
+        ).size;
       }
       case "countEmpty":
         return values.filter((v) => v == null || v === "").length;
@@ -12231,7 +12229,6 @@ var WorkflowAccessGrantService = class extends BaseService {
 };
 
 // src/runtime/services/workflow/instance.service.ts
-import { randomUUID } from "crypto";
 var WorkflowInstanceService = class extends BaseService {
   constructor(adapter, workflowService, options) {
     super(adapter);
@@ -12497,7 +12494,7 @@ var WorkflowInstanceService = class extends BaseService {
         updatedAt: /* @__PURE__ */ new Date()
       };
     }
-    const executionId = randomUUID();
+    const executionId = generateId();
     let current = {
       ...instance,
       context: {
@@ -13407,7 +13404,7 @@ var WorkflowService = class extends BaseService {
     };
     const validationResult = WorkflowDefinitionSchema.safeParse(definition);
     if (!validationResult.success) {
-      const errors = validationResult.error.issues.map((i) => i.message);
+      const errors = formatZodErrors(validationResult.error).map((err) => err.message);
       throw new SchemaError(
         `Invalid workflow definition: ${errors.join(", ")}`,
         SchemaErrorCode.VALIDATION_FAILED
@@ -13449,7 +13446,7 @@ var WorkflowService = class extends BaseService {
     };
     const validationResult = WorkflowDefinitionSchema.safeParse(updated);
     if (!validationResult.success) {
-      const errors = validationResult.error.issues.map((i) => i.message);
+      const errors = formatZodErrors(validationResult.error).map((err) => err.message);
       throw new SchemaError(
         `Invalid workflow definition: ${errors.join(", ")}`,
         SchemaErrorCode.VALIDATION_FAILED
@@ -13478,7 +13475,7 @@ var WorkflowService = class extends BaseService {
     }
     const validationResult = WorkflowDefinitionSchema.safeParse(existing);
     if (!validationResult.success) {
-      const errors = validationResult.error.issues.map((i) => i.message);
+      const errors = formatZodErrors(validationResult.error).map((err) => err.message);
       throw new SchemaError(
         `Cannot publish invalid workflow: ${errors.join(", ")}`,
         SchemaErrorCode.VALIDATION_FAILED
@@ -14563,7 +14560,7 @@ var DocumentService = class extends BaseService {
     const template = await this.templateService.getTemplateOrThrow(document2.templateId);
     const slots = await this.getSlots(documentId);
     const requiredSlots = template.slots.filter((s) => s.required);
-    const filledSlotNames = new Set(slots.map((s) => s.slotName));
+    const filledSlotNames = slots.reduce((set, s) => set.add(s.slotName), /* @__PURE__ */ new Set());
     const allRequiredFilled = requiredSlots.every((s) => filledSlotNames.has(s.name));
     if (!allRequiredFilled) {
       return await this.updateStatus(documentId, "draft");
@@ -16137,7 +16134,7 @@ var PermissionService = class extends BaseService {
       DEFAULT_ROLE_PERMISSIONS
     } = await import("./default-roles-42X3TJI5.mjs");
     const existingRoles = await this.getRoles();
-    const existingRoleNames = new Set(existingRoles.map((r) => r.name));
+    const existingRoleNames = existingRoles.reduce((set, r) => set.add(r.name), /* @__PURE__ */ new Set());
     for (const roleName of Object.values(DEFAULT_ROLES)) {
       if (existingRoleNames.has(roleName)) {
         continue;
@@ -16172,124 +16169,340 @@ var PermissionService = class extends BaseService {
 
 // src/runtime/services/view.service.ts
 var ViewService = class extends BaseService {
-  constructor(adapter, nativeViews) {
+  constructor(adapter) {
     super(adapter);
-    this.nativeViews = nativeViews;
   }
   // ============================================================================
   // CACHE MANAGEMENT
   // ============================================================================
-  /**
-   * Invalidate cached views for an object.
-   * Called automatically after view mutations.
-   */
   async invalidateViewCache(objectName) {
     await this.invalidateCache(cacheKeys.viewsByObject(this.tenantId, objectName));
   }
+  // ============================================================================
+  // READ METHODS
+  // ============================================================================
   /**
-   * Get all views for an object (native + custom).
-   * Automatically uses tenant context from AsyncLocalStorage.
+   * Get all views for the current tenant.
+   * Optionally filter by view type.
    *
-   * Results are cached if a CacheAdapter is configured.
+   * @param type - Optional view type filter
+   * @returns All views for the tenant
+   */
+  async getAllViews(type) {
+    const dbViews = await this.adapter.views.findAllForTenant(type);
+    return dbViews.map((v) => this.convertDBViewToDefinition(v));
+  }
+  /**
+   * Get a specific view by its ID.
+   * Returns null if not found.
    *
-   * @param objectName - Object name
-   * @returns All views for the object
+   * @param viewId - View ID (UUID)
+   * @returns View definition or null
    */
-  async getViewsForObject(objectName) {
-    return this.cachedBy("viewsByObject", objectName, () => this.fetchViewsForObject(objectName));
+  async getViewById(viewId) {
+    const dbView = await this.adapter.views.findById(viewId);
+    if (!dbView) {
+      return null;
+    }
+    return this.convertDBViewToDefinition(dbView);
   }
   /**
-   * Internal method to fetch views for an object (no caching)
+   * Get all views for an object from the database.
+   * Optionally filter by type and merge with user overlays.
+   *
+   * @param objectName - Object name
+   * @param options - Filter and overlay options
+   * @returns Views from database
    */
-  async fetchViewsForObject(objectName) {
-    const nativeViewDefs = this.nativeViews.getByObjectName(objectName);
-    const dbViews = await this.adapter.views.findByObjectName(objectName);
-    const customViews = dbViews.filter((v) => !v.system).map(this.convertDBViewToDefinition);
-    return [...nativeViewDefs, ...customViews];
+  async getViews(objectName, options = {}) {
+    const { type, userId } = options;
+    const dbViews = await this.adapter.views.findByObjectName(objectName, type);
+    const views = dbViews.map((v) => this.convertDBViewToDefinition(v));
+    if (!userId) {
+      return views;
+    }
+    const userOverlays = await this.adapter.viewOverlays.findByUser(userId);
+    return views.map((view2) => {
+      const overlay = userOverlays.find((o) => o.viewId === view2.id);
+      return overlay ? this.applyOverlay(view2, overlay) : view2;
+    });
   }
   /**
    * Get a specific view by name.
-   * Automatically uses tenant context from AsyncLocalStorage.
+   * Returns null if not found (use getDefaultView for fallback behavior).
    *
    * @param objectName - Object name
    * @param viewName - View name
-   * @returns View definition or null
-   */
-  async getView(objectName, viewName) {
-    const nativeView = this.nativeViews.get(objectName, viewName);
-    if (nativeView) {
-      return nativeView;
+   * @param options - Type filter and overlay options
+   * @returns View or null
+   */
+  async getView(objectName, viewName, options = {}) {
+    const { type, userId } = options;
+    let dbView;
+    if (type) {
+      dbView = await this.adapter.views.findByNameAndType(objectName, viewName, type);
+    } else {
+      dbView = await this.adapter.views.findByName(objectName, viewName);
+    }
+    if (!dbView) {
+      return null;
     }
-    const dbView = await this.adapter.views.findByName(objectName, viewName);
-    if (dbView) {
-      return this.convertDBViewToDefinition(dbView);
+    const view2 = this.convertDBViewToDefinition(dbView);
+    if (!userId) {
+      return view2;
     }
-    return null;
+    const overlay = await this.adapter.viewOverlays.findByViewAndUser(dbView.id, userId);
+    return overlay ? this.applyOverlay(view2, overlay) : view2;
   }
   /**
-   * Get the default view for an object
+   * Get the default view for an object and type.
+   * If no view exists in DB, auto-creates and persists a default view.
    *
    * Priority:
-   * 1. Custom view marked as default (for the specified layout)
-   * 2. Native view marked as default (for the specified layout)
-   * 3. First available view (for the specified layout)
+   * 1. User's preferred view (from overlay with isUserDefault=true)
+   * 2. View marked as default in DB (with matching layout if specified)
+   * 3. First available view (with matching layout if specified)
+   * 4. Auto-created default view (persisted to DB)
    *
    * @param objectName - Object name
-   * @param layout - Optional layout filter ("page" or "modal")
-   * @returns Default view or null
+   * @param type - View type
+   * @param objectDefinition - Object definition (for default generation)
+   * @param options - Optional filters (userId, layout for detail views)
+   * @returns View definition (existing or auto-created)
+   */
+  async getDefaultView(objectName, type, objectDefinition, options) {
+    const { userId, layout } = options ?? {};
+    const matchesLayout = (view2) => {
+      if (!layout || type !== "detail") return true;
+      const detailView2 = view2;
+      return detailView2.config.layout === layout;
+    };
+    const applyUserOverlay = async (view2, viewId) => {
+      if (!userId) return view2;
+      const overlay = await this.adapter.viewOverlays.findByViewAndUser(viewId, userId);
+      return overlay ? this.applyOverlay(view2, overlay) : view2;
+    };
+    if (userId) {
+      const userDefaultOverlay = await this.adapter.viewOverlays.findUserDefault(
+        userId,
+        objectName,
+        type
+      );
+      if (userDefaultOverlay) {
+        const dbView = await this.adapter.views.findById(userDefaultOverlay.viewId);
+        if (dbView && dbView.type === type) {
+          const view2 = this.convertDBViewToDefinition(dbView);
+          if (matchesLayout(view2)) {
+            return this.applyOverlay(view2, userDefaultOverlay);
+          }
+        }
+      }
+    }
+    const defaultDbView = await this.adapter.views.findDefault(objectName, type);
+    if (defaultDbView) {
+      const view2 = this.convertDBViewToDefinition(defaultDbView);
+      if (matchesLayout(view2)) {
+        return await applyUserOverlay(view2, defaultDbView.id);
+      }
+    }
+    const dbViews = await this.adapter.views.findByObjectName(objectName, type);
+    for (const dbView of dbViews) {
+      const view2 = this.convertDBViewToDefinition(dbView);
+      if (matchesLayout(view2)) {
+        return await applyUserOverlay(view2, dbView.id);
+      }
+    }
+    if (dbViews.length > 0) {
+      const firstView = dbViews[0];
+      const view2 = this.convertDBViewToDefinition(firstView);
+      return await applyUserOverlay(view2, firstView.id);
+    }
+    const created = await this.ensureDefaultView(objectName, type, objectDefinition, layout);
+    if (userId) {
+      if (!created.id) {
+        throw new Error("Created view missing ID - this should never happen");
+      }
+      const overlay = await this.adapter.viewOverlays.findByViewAndUser(created.id, userId);
+      return overlay ? this.applyOverlay(created, overlay) : created;
+    }
+    return created;
+  }
+  // ============================================================================
+  // DEFAULT VIEW GENERATION
+  // ============================================================================
+  /**
+   * Ensure a default view exists in DB for the given object and type.
+   * If no view exists, generates and persists one.
+   * Idempotent — safe to call concurrently (uses upsert).
    */
-  async getDefaultView(objectName, layout) {
-    const views = await this.getViewsForObject(objectName);
-    const filtered = layout ? views.filter((v) => (v.layout ?? "page") === layout) : views;
-    const customDefault = filtered.find((v) => v.default && !v.system);
-    if (customDefault) return customDefault;
-    const nativeDefault = filtered.find((v) => v.default && v.system);
-    if (nativeDefault) return nativeDefault;
-    return filtered[0] ?? null;
+  async ensureDefaultView(objectName, type, objectDefinition, layout) {
+    const generated = this.generateDefaultViewConfig(objectName, type, objectDefinition, layout);
+    const viewName = type === "detail" && layout === "modal" ? "default-modal" : "default";
+    const dbView = await this.adapter.views.upsert({
+      objectName,
+      type,
+      name: viewName,
+      label: generated.label,
+      config: generated.config,
+      default: true
+    });
+    const legacyFallbackId = `fallback:${objectName}:${type}`;
+    await this.adapter.viewOverlays.migrateViewId(legacyFallbackId, dbView.id);
+    await this.invalidateViewCache(objectName);
+    return this.convertDBViewToDefinition(dbView);
   }
   /**
-   * Create a custom view.
-   * Automatically uses tenant context from AsyncLocalStorage.
+   * Generate default view config for an object.
+   * Used by ensureDefaultView() and resetViewToDefault().
+   */
+  generateDefaultViewConfig(objectName, type, objectDefinition, layout) {
+    switch (type) {
+      case "detail":
+        return this.generateDefaultDetailConfig(objectName, objectDefinition, layout);
+      case "list":
+        return this.generateDefaultListConfig(objectName, objectDefinition);
+      default:
+        throw new SchemaError(
+          `Default view generation not supported for type: ${type}`,
+          SchemaErrorCode.VALIDATION_FAILED,
+          { type }
+        );
+    }
+  }
+  generateDefaultDetailConfig(objectName, object2, layout = "page") {
+    const visibleAttrs = object2.attributes.filter(
+      (attr) => !(attr.hidden || attr.archived || attr.system)
+    );
+    const fields = visibleAttrs.sort((a, b) => (a.order ?? 999) - (b.order ?? 999)).map((attr) => ({
+      attribute: attr.name,
+      span: this.getDefaultFieldSpan(attr.type)
+    }));
+    const formTab = {
+      id: "form",
+      name: "form",
+      label: "Details",
+      type: "form",
+      groups: [
+        {
+          id: "general",
+          label: "General",
+          fields,
+          order: 0
+        }
+      ],
+      order: 0
+    };
+    const tabs = [formTab];
+    tabs.push({
+      id: "activity",
+      name: "activity",
+      label: "Activity",
+      type: "activity",
+      order: 1
+    });
+    tabs.push({
+      id: "notes",
+      name: "notes",
+      label: "Notes",
+      type: "notes",
+      order: 2,
+      allowCreate: true
+    });
+    const hasDocuments = object2.attributes.some((attr) => attr.type === "document");
+    if (hasDocuments) {
+      tabs.push({
+        id: "documents",
+        name: "documents",
+        label: "Documents",
+        type: "documents",
+        order: 3,
+        allowUpload: true,
+        allowRemove: true,
+        showProcessing: true
+      });
+    }
+    const config = {
+      layout,
+      tabs
+    };
+    return {
+      name: "default",
+      label: "Default View",
+      object: objectName,
+      type: "detail",
+      config,
+      default: true
+    };
+  }
+  generateDefaultListConfig(objectName, object2) {
+    const visibleAttrs = object2.attributes.filter(
+      (attr) => !(attr.hidden || attr.archived || attr.system)
+    );
+    const columns = visibleAttrs.sort((a, b) => (a.order ?? 999) - (b.order ?? 999)).slice(0, 5).map((attr) => attr.name);
+    const config = {
+      layout: "table",
+      columns
+    };
+    return {
+      name: "default",
+      label: "All Records",
+      object: objectName,
+      type: "list",
+      config,
+      default: true
+    };
+  }
+  getDefaultFieldSpan(type) {
+    switch (type) {
+      case "textarea":
+      case "richtext":
+      case "location":
+        return 12;
+      case "checkbox":
+        return 4;
+      default:
+        return 6;
+    }
+  }
+  // ============================================================================
+  // WRITE METHODS (Architect Mode)
+  // ============================================================================
+  /**
+   * Create a new view (Architect Mode).
    *
    * @param input - View definition
    * @returns Created view
    */
   async createView(input) {
     this.validateViewName(input.name);
-    this.validateModalLayout(input.tabs, input.layout);
-    const existing = await this.adapter.views.findByName(input.objectName, input.name);
+    const existing = await this.adapter.views.findByNameAndType(
+      input.objectName,
+      input.name,
+      input.type
+    );
     if (existing) {
       throw new SchemaError(
-        `View "${input.name}" already exists for object "${input.objectName}"`,
-        SchemaErrorCode.DUPLICATE_ATTRIBUTE,
-        { viewName: input.name, objectName: input.objectName }
-      );
-    }
-    if (this.nativeViews.has(input.objectName, input.name)) {
-      throw new SchemaError(
-        `Cannot create view "${input.name}": a system view with this name already exists`,
+        `View "${input.name}" of type "${input.type}" already exists for object "${input.objectName}"`,
         SchemaErrorCode.DUPLICATE_ATTRIBUTE,
-        { viewName: input.name, objectName: input.objectName, system: true }
+        { viewName: input.name, type: input.type, objectName: input.objectName }
       );
     }
     const dbView = await this.adapter.views.create({
       objectName: input.objectName,
+      type: input.type,
       name: input.name,
       label: input.label,
       description: input.description,
       icon: input.icon,
-      layout: input.layout,
-      tabs: input.tabs ?? [],
-      default: input.default ?? false,
-      system: false,
-      // Custom views are never system
+      config: input.config,
+      default: input.default,
       metadata: input.metadata
     });
     await this.invalidateViewCache(input.objectName);
     return this.convertDBViewToDefinition(dbView);
   }
   /**
-   * Update a custom view
+   * Update an existing view.
    *
    * @param viewId - View ID
    * @param input - Update data
@@ -16300,18 +16513,11 @@ var ViewService = class extends BaseService {
     if (!dbView) {
       throw new NotFoundError("View", viewId);
     }
-    if (dbView.system) {
-      throw new ProtectedResourceError("view", dbView.name, "modify");
-    }
-    const effectiveLayout = input.layout ?? dbView.layout;
-    const effectiveTabs = input.tabs ?? dbView.tabs;
-    this.validateModalLayout(effectiveTabs, effectiveLayout);
     const updated = await this.adapter.views.update(viewId, {
       label: input.label,
       description: input.description,
       icon: input.icon,
-      layout: input.layout,
-      tabs: input.tabs,
+      config: input.config,
       default: input.default,
       metadata: input.metadata
     });
@@ -16319,7 +16525,8 @@ var ViewService = class extends BaseService {
     return this.convertDBViewToDefinition(updated);
   }
   /**
-   * Delete a custom view
+   * Delete a view.
+   * Overlays are automatically deleted (cascade).
    *
    * @param viewId - View ID
    */
@@ -16328,16 +16535,12 @@ var ViewService = class extends BaseService {
     if (!dbView) {
       throw new NotFoundError("View", viewId);
     }
-    if (dbView.system) {
-      throw new ProtectedResourceError("view", dbView.name, "delete");
-    }
+    await this.adapter.viewOverlays.deleteByView(viewId);
     await this.adapter.views.delete(viewId);
     await this.invalidateViewCache(dbView.objectName);
   }
   /**
-   * Set a view as default for its object and layout.
-   * Only unsets other defaults for the same layout.
-   * Automatically uses tenant context from AsyncLocalStorage.
+   * Set a view as default for its object and type.
    *
    * @param viewId - View ID
    * @returns Updated view
@@ -16347,11 +16550,9 @@ var ViewService = class extends BaseService {
     if (!dbView) {
       throw new NotFoundError("View", viewId);
     }
-    const viewLayout = dbView.layout ?? "page";
-    const currentViews = await this.adapter.views.findByObjectName(dbView.objectName);
+    const currentViews = await this.adapter.views.findByObjectName(dbView.objectName, dbView.type);
     for (const v of currentViews) {
-      const vLayout = v.layout ?? "page";
-      if (v.default && v.id !== viewId && !v.system && vLayout === viewLayout) {
+      if (v.default && v.id !== viewId) {
         await this.adapter.views.update(v.id, { default: false });
       }
     }
@@ -16359,12 +16560,140 @@ var ViewService = class extends BaseService {
     await this.invalidateViewCache(dbView.objectName);
     return this.convertDBViewToDefinition(updated);
   }
+  /**
+   * Reset a view to its default (auto-generated) state.
+   * Regenerates the view config based on the object definition.
+   *
+   * @param viewId - View ID
+   * @param objectDefinition - Object definition for regeneration
+   * @returns Updated view
+   */
+  async resetViewToDefault(viewId, objectDefinition) {
+    const dbView = await this.adapter.views.findById(viewId);
+    if (!dbView) {
+      throw new NotFoundError("View", viewId);
+    }
+    const generated = this.generateDefaultViewConfig(
+      dbView.objectName,
+      dbView.type,
+      objectDefinition,
+      dbView.type === "detail" ? dbView.config?.layout ?? "page" : void 0
+    );
+    const newConfig = generated.config;
+    const updated = await this.adapter.views.update(viewId, { config: newConfig });
+    await this.invalidateViewCache(dbView.objectName);
+    return this.convertDBViewToDefinition(updated);
+  }
   // ============================================================================
-  // PRIVATE HELPERS
+  // USER CUSTOMIZATION METHODS
   // ============================================================================
   /**
-   * Validate view name format (kebab-case)
+   * Reset user customizations for a view.
+   * Deletes the overlay, returning to source/fallback view.
+   *
+   * @param viewId - View ID (can be UUID or fallback ID)
+   * @param userId - User ID
+   */
+  async resetUserCustomizations(viewId, userId) {
+    await this.adapter.viewOverlays.deleteByViewAndUser(viewId, userId);
+  }
+  /**
+   * Set a view as the user's default for an object and type.
+   *
+   * @param viewId - View ID (can be UUID or fallback ID)
+   * @param userId - User ID
+   * @param objectName - Object name
+   * @param type - View type
+   */
+  async setUserDefaultView(viewId, userId, objectName, type) {
+    await this.adapter.viewOverlays.clearUserDefault(userId, objectName, type);
+    const existingOverlay = await this.adapter.viewOverlays.findByViewAndUser(viewId, userId);
+    if (existingOverlay) {
+      await this.adapter.viewOverlays.update(existingOverlay.id, { isUserDefault: true });
+    } else {
+      await this.adapter.viewOverlays.create({
+        viewId,
+        userId,
+        configOverrides: {},
+        isUserDefault: true
+      });
+    }
+  }
+  /**
+   * Check if a user has customized a view.
+   *
+   * @param viewId - View ID
+   * @param userId - User ID
+   * @returns True if overlay exists
+   */
+  async hasUserCustomizations(viewId, userId) {
+    const overlay = await this.adapter.viewOverlays.findByViewAndUser(viewId, userId);
+    return overlay !== null && hasProperties(overlay.configOverrides);
+  }
+  // ============================================================================
+  // OVERLAY MERGE LOGIC
+  // ============================================================================
+  /**
+   * Apply an overlay to a view definition.
+   * Implements merge semantics defined in the plan.
+   *
+   * @param view - Source view definition
+   * @param overlay - User overlay
+   * @returns Merged view definition
+   */
+  applyOverlay(view2, overlay) {
+    const overrides = overlay.configOverrides;
+    switch (view2.type) {
+      case "list":
+        return this.applyListViewOverlay(view2, overrides);
+      case "detail":
+        return this.applyDetailViewOverlay(view2, overrides);
+      default:
+        return view2;
+    }
+  }
+  applyListViewOverlay(view2, overrides) {
+    const mergedConfig = {
+      ...view2.config,
+      tabs: this.mergeViewTabs(view2.config.tabs, overrides.tabs, overrides.hiddenTabIds)
+    };
+    return { ...view2, config: mergedConfig };
+  }
+  applyDetailViewOverlay(view2, overrides) {
+    const mergedConfig = {
+      ...view2.config,
+      // Append for tabs (detail tabs)
+      tabs: this.mergeDetailTabs(
+        view2.config.tabs,
+        overrides.detailTabs,
+        overrides.hiddenDetailTabIds
+      )
+    };
+    return {
+      ...view2,
+      config: mergedConfig
+    };
+  }
+  /**
+   * Merge source tabs with overlay tabs.
+   * - Source tabs are visible to all
+   * - Overlay tabs are appended (user-private)
+   * - hiddenTabIds allows hiding source tabs
+   */
+  mergeViewTabs(sourceTabs = [], overlayTabs = [], hiddenTabIds = []) {
+    const visibleSourceTabs = sourceTabs.filter((t) => !hiddenTabIds.includes(t.id));
+    return [...visibleSourceTabs, ...overlayTabs];
+  }
+  /**
+   * Merge detail tabs (form, activity, etc.)
    */
+  mergeDetailTabs(sourceTabs = [], overlayTabs = [], hiddenTabIds = []) {
+    const visibleSourceTabs = sourceTabs.filter((t) => !hiddenTabIds.includes(t.id));
+    return [...visibleSourceTabs, ...overlayTabs];
+  }
+  // ============================================================================
+  // PRIVATE HELPERS
+  // ============================================================================
   validateViewName(name) {
     if (!name || name.length === 0) {
       throw new ValidationError("View name cannot be empty", [
@@ -16386,66 +16715,72 @@ var ViewService = class extends BaseService {
       ]);
     }
   }
-  /**
-   * Validate modal layout constraints.
-   * Modal views must have exactly one form tab.
-   */
-  validateModalLayout(tabs, layout) {
-    if (layout !== "modal") return;
-    if (!tabs || tabs.length === 0) {
-      throw new ValidationError("Modal views must have exactly one form tab", [
-        { path: ["tabs"], message: "Modal views must have exactly one form tab" }
-      ]);
-    }
-    if (tabs.length > 1) {
-      throw new ValidationError("Modal views can only have one tab", [
-        { path: ["tabs"], message: "Modal views can only have one tab" }
-      ]);
-    }
-    if (tabs[0].type !== "form") {
-      throw new ValidationError("Modal views must have a form tab", [
-        { path: ["tabs"], message: `Modal views must have a form tab, not a ${tabs[0].type}` }
-      ]);
-    }
-  }
   /**
    * Convert database view to ViewDefinition
    */
   convertDBViewToDefinition(dbView) {
-    return {
+    const base = {
       id: dbView.id,
       name: dbView.name,
       label: dbView.label,
       description: dbView.description,
       icon: dbView.icon,
       object: dbView.objectName,
-      layout: dbView.layout,
-      tabs: dbView.tabs,
       default: dbView.default,
-      system: dbView.system,
       metadata: dbView.metadata
     };
+    switch (dbView.type) {
+      case "detail": {
+        const detailView2 = {
+          ...base,
+          type: "detail",
+          config: dbView.config
+        };
+        return detailView2;
+      }
+      case "list": {
+        const listView2 = {
+          ...base,
+          type: "list",
+          config: dbView.config
+        };
+        return listView2;
+      }
+      // TODO: Add proper config types for calendar, timeline, gallery when implemented
+      case "calendar":
+      case "timeline":
+      case "gallery":
+        return { ...base, type: dbView.type, config: dbView.config };
+      default:
+        throw new SchemaError(
+          `Unknown view type: ${dbView.type}`,
+          SchemaErrorCode.VALIDATION_FAILED,
+          { type: dbView.type }
+        );
+    }
   }
 };
 
 // src/runtime/view-sync.ts
-async function syncNativeViews(adapter, nativeViewRegistry, options = {}) {
+async function seedRegistryViews(adapter, registry2, options = {}) {
   const result = {
     success: true,
     viewsSynced: 0,
     viewsCreated: 0,
-    viewsUpdated: 0,
+    viewsSkipped: 0,
     viewsDeleted: 0,
     errors: []
   };
-  const nativeViews = nativeViewRegistry.getAll();
+  const registryViews = registry2.getAll();
   if (options.verbose && options.logger) {
-    options.logger.info(`[ViewSync] Starting sync for ${nativeViews.length} native views...`);
+    options.logger.info(`[ViewSync] Starting seed for ${registryViews.length} registry views...`);
   }
   try {
     await adapter.transaction(async (tx) => {
-      const viewsByObject = await syncAllViews(tx, nativeViews, result, options);
-      await cleanupRemovedViews(tx, viewsByObject, result, options);
+      const viewsByObjectAndType = await seedAllViews(tx, registryViews, result, options);
+      if (options.deleteOrphans) {
+        await cleanupOrphanViews(tx, viewsByObjectAndType, result, options);
+      }
     });
   } catch (error2) {
     handleTransactionError(result, error2);
@@ -16453,38 +16788,78 @@ async function syncNativeViews(adapter, nativeViewRegistry, options = {}) {
   logSyncComplete(result, options);
   return result;
 }
-async function syncAllViews(tx, nativeViews, result, options) {
-  const viewsByObject = /* @__PURE__ */ new Map();
-  for (const nativeView of nativeViews) {
+var syncNativeViews = seedRegistryViews;
+async function seedAllViews(tx, registryViews, result, options) {
+  const viewsByObjectAndType = /* @__PURE__ */ new Map();
+  for (const view2 of registryViews) {
     try {
-      await syncSingleView(tx, nativeView, result, options);
-      trackViewByObject(viewsByObject, nativeView);
+      await seedSingleView(tx, view2, result, options);
+      trackViewByObjectAndType(viewsByObjectAndType, view2);
     } catch (error2) {
-      handleViewSyncError(result, nativeView, error2, options);
+      handleViewSyncError(result, view2, error2);
+    }
+  }
+  return viewsByObjectAndType;
+}
+async function seedSingleView(adapter, view2, result, options) {
+  const exists = await adapter.views.exists(view2.object, view2.name, view2.type);
+  if (exists) {
+    result.viewsSkipped++;
+    result.viewsSynced++;
+    if (options.verbose && options.logger) {
+      options.logger.info(`[ViewSync] Skipped (exists): ${view2.object}:${view2.name}:${view2.type}`);
+    }
+    return;
+  }
+  if (options.dryRun) {
+    result.viewsCreated++;
+    result.viewsSynced++;
+    if (options.verbose && options.logger) {
+      options.logger.info(`[ViewSync] Would create: ${view2.object}:${view2.name}:${view2.type}`);
     }
+    return;
+  }
+  await adapter.views.upsert({
+    objectName: view2.object,
+    type: view2.type,
+    name: view2.name,
+    label: view2.label,
+    description: view2.description,
+    icon: view2.icon,
+    config: view2.config,
+    default: view2.default ?? false,
+    metadata: view2.metadata
+  });
+  result.viewsCreated++;
+  result.viewsSynced++;
+  if (options.verbose && options.logger) {
+    options.logger.info(`[ViewSync] \u2713 Created: ${view2.object}:${view2.name}:${view2.type}`);
   }
-  return viewsByObject;
 }
-function trackViewByObject(viewsByObject, nativeView) {
-  const objectViews = viewsByObject.get(nativeView.object) ?? [];
-  objectViews.push(nativeView.name);
-  viewsByObject.set(nativeView.object, objectViews);
+function trackViewByObjectAndType(viewsByObjectAndType, view2) {
+  const key = `${view2.object}:${view2.type}`;
+  const viewNames = viewsByObjectAndType.get(key) ?? [];
+  viewNames.push(view2.name);
+  viewsByObjectAndType.set(key, viewNames);
 }
-function handleViewSyncError(result, nativeView, error2, _options) {
+function handleViewSyncError(result, view2, error2) {
   result.success = false;
   result.errors.push({
-    viewName: nativeView.name,
-    objectName: nativeView.object,
+    viewName: view2.name,
+    objectName: view2.object,
     error: error2 instanceof Error ? error2.message : String(error2)
   });
 }
-async function cleanupRemovedViews(tx, viewsByObject, result, options) {
+async function cleanupOrphanViews(tx, viewsByObjectAndType, result, options) {
   if (options.dryRun) return;
-  for (const [objectName, viewNames] of viewsByObject) {
-    const deletedCount = await tx.views.deleteNotIn(objectName, viewNames);
+  for (const [key, viewNames] of viewsByObjectAndType) {
+    const [objectName, type] = key.split(":");
+    const deletedCount = await tx.views.deleteNotIn(objectName, type, viewNames);
     result.viewsDeleted += deletedCount;
     if (options.verbose && deletedCount > 0 && options.logger) {
-      options.logger.info(`[ViewSync] Deleted ${deletedCount} obsolete views for ${objectName}`);
+      options.logger.info(
+        `[ViewSync] Deleted ${deletedCount} orphan ${type} views for ${objectName}`
+      );
     }
   }
 }
@@ -16499,63 +16874,27 @@ function handleTransactionError(result, error2) {
 function logSyncComplete(result, options) {
   if (options.verbose && options.logger) {
     options.logger.info(
-      `[ViewSync] ${result.success ? "\u2713" : "\u2717"} Sync complete:
-  Views: ${result.viewsCreated} created, ${result.viewsUpdated} updated, ${result.viewsDeleted} deleted
+      `[ViewSync] ${result.success ? "\u2713" : "\u2717"} Seed complete:
+  Views: ${result.viewsCreated} created, ${result.viewsSkipped} skipped, ${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 && options.logger) {
-      options.logger.info(
-        `[ViewSync] Would ${isNew ? "create" : "update"} view: ${nativeView.object}:${nativeView.name}`
-      );
-    }
-    return;
-  }
-  await adapter.views.upsert({
-    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 && options.logger) {
-    options.logger.info(
-      `[ViewSync] \u2713 Synced ${nativeView.object}:${nativeView.name}: ${nativeView.tabs.length} tabs`
-    );
-  }
-}
-async function verifyNativeViewsSync(adapter, nativeViewRegistry) {
-  const nativeViews = nativeViewRegistry.getAll();
-  for (const view2 of nativeViews) {
-    if (!view2.system) continue;
-    const existing = await adapter.views.findSystemByName(view2.object, view2.name);
-    if (!existing) {
+async function verifyRegistryViewsSeeded(adapter, registry2) {
+  const registryViews = registry2.getAll();
+  for (const view2 of registryViews) {
+    const exists = await adapter.views.exists(view2.object, view2.name, view2.type);
+    if (!exists) {
       return false;
     }
   }
   return true;
 }
-async function getViewSyncPreview(adapter, nativeViewRegistry) {
-  return await syncNativeViews(adapter, nativeViewRegistry, { dryRun: true });
+var verifyNativeViewsSync = verifyRegistryViewsSeeded;
+async function getViewSeedPreview(adapter, registry2) {
+  return await seedRegistryViews(adapter, registry2, { dryRun: true });
 }
+var getViewSyncPreview = getViewSeedPreview;
 
 // src/runtime/sync.ts
 var BASE_ATTRIBUTE_KEYS = /* @__PURE__ */ new Set([
@@ -16664,8 +17003,9 @@ async function handleDryRun(adapter, nativeObject, existingObject, result, optio
   if (options.verbose) {
     console.info(`[SyncService] Would ${isNew ? "create" : "update"} object: ${nativeObject.name}`);
   }
+  const existingAttrs = existingObject ? await adapter.attributes.findByObjectId(existingObject.id) : [];
   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;
+    const existingAttr = existingAttrs.find((a) => a.name === attr.name) ?? null;
     if (existingAttr) {
       result.attributesUpdated++;
     } else {
@@ -16687,8 +17027,9 @@ async function upsertObject(adapter, nativeObject, _options) {
   });
 }
 async function syncAttributes(adapter, nativeObject, dbObject, existingObject, result) {
+  const existingAttrs = existingObject ? await adapter.attributes.findByObjectId(dbObject.id) : [];
   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;
+    const existingAttr = existingAttrs.find((a) => a.name === attr.name) ?? null;
     await adapter.attributes.upsert({
       objectId: dbObject.id,
       name: attr.name,
@@ -16755,7 +17096,7 @@ async function syncAll(adapter, objectRegistry, nativeViewRegistry, options = {}
     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)
+  Views: ${viewsResult.viewsSynced} synced (${viewsResult.viewsCreated} created, ${viewsResult.viewsSkipped} skipped)
   Errors: ${objectsResult.errors.length + viewsResult.errors.length}`
     );
   }
@@ -16776,6 +17117,12 @@ var NoopGeocodingAdapter = class {
 };
 
 export {
+  IDENTITY_PROPERTIES,
+  BEHAVIOR_PROPERTIES,
+  PRESENTATION_PROPERTIES,
+  isIdentityProperty,
+  isBehaviorProperty,
+  isPresentationProperty,
   RELATION_TARGET_ANY,
   isUniversalRelation,
   RecordReferencedError,
@@ -16804,8 +17151,6 @@ export {
   and,
   or,
   inValues,
-  isEmpty,
-  isNotEmpty,
   isWorkflowDefinition,
   isWorkflowPublished,
   isSystemWorkflow,
@@ -16824,7 +17169,6 @@ export {
   createEmptyContext,
   getContextValue,
   setContextValue,
-  mergeFormToSlot,
   DEFAULT_THEME,
   mergeWithDefaults,
   generateCssVariables,
@@ -16858,12 +17202,10 @@ export {
   WorkflowConfigSchema,
   WorkflowStatusSchema,
   WorkflowDefinitionSchema,
-  asTenantId,
-  asUserId,
-  generateId,
-  generatePrefixedId,
-  slugify,
-  generateTemplateName,
+  isEmpty,
+  isNotEmpty,
+  toUndefinedIfEmpty,
+  hasProperties,
   EMPTY_VALUE_PLACEHOLDER,
   formatAttributeValue,
   SchemaErrorCode,
@@ -16888,7 +17230,6 @@ export {
   RoleNotFoundError,
   isForbiddenError,
   ConcurrentModificationError,
-  isConcurrentModificationError,
   text,
   textarea,
   richtext,
@@ -16919,8 +17260,13 @@ export {
   FlowsTabConfig,
   DocumentsTabConfig,
   TabBuilder,
+  DetailViewBuilder,
   ViewBuilder,
+  detailView,
   view,
+  ListViewBuilder,
+  ListViewTabConfigBuilder,
+  listView,
   group,
   WorkflowFormRowBuilder,
   WorkflowFormBuilder,
@@ -16941,63 +17287,6 @@ export {
   SYSTEM_TEMPLATES,
   getSystemTemplate,
   isSystemTemplate,
-  DEFAULT_VALIDATION_MESSAGES,
-  textConfigSchema,
-  textareaConfigSchema,
-  richtextConfigSchema,
-  numberConfigSchema,
-  checkboxConfigSchema,
-  dateConfigSchema,
-  phoneConfigSchema,
-  currencyConfigSchema,
-  statusConfigSchema,
-  locationConfigSchema,
-  selectConfigSchema,
-  multiselectConfigSchema,
-  fileConfigSchema,
-  userConfigSchema,
-  relationConfigSchema,
-  ratingConfigSchema,
-  formulaConfigSchema,
-  rollupConfigSchema,
-  documentConfigSchema,
-  attributeConfigSchemas,
-  getAttributeConfigSchema,
-  validateAttributeConfig,
-  parseAttributeConfig,
-  safeParseAttributeConfig,
-  createTextValidator,
-  createNumberValidator,
-  createCheckboxValidator,
-  createDateValidator,
-  createPhoneValidator,
-  createCurrencyValidator,
-  createStatusValidator,
-  createSelectValidator,
-  createMultiselectValidator,
-  createLocationValidator,
-  createFileValidator,
-  createUserValidator,
-  createSingleRelationValidator,
-  createMultiRelationValidator,
-  createRelationValidator,
-  createRatingValidator,
-  createFormulaValidator,
-  createRollupValidator,
-  createTextAreaValidator,
-  createRichtextValidator,
-  createAttributeValidator,
-  createFormAttributeValidator,
-  createObjectValidator,
-  validateAttribute,
-  validateObject,
-  validateObjectOrThrow,
-  createDraftValidator,
-  validateDraft,
-  validateDraftOrThrow,
-  getMissingRequiredAttributes,
-  isRecordComplete,
-  computeRecordStatus,
   WorkflowJwtService,
   hashOptions,
   cacheKeys,
@@ -17011,6 +17300,14 @@ export {
   QueryNoResultError,
   QueryMultipleResultsError,
   TenantContextError,
+  FeatureFlagsContextError,
+  isFeatureEnabled,
+  getFeatureValue,
+  getFeatureFlags,
+  tryGetFeatureValue,
+  hasFeatureFlagsContext,
+  runWithFeatureFlags,
+  withFeatureFlags,
   getSchemaFromContext,
   getSchemaByNameFromContext,
   hasSchemaContext,
@@ -17018,7 +17315,7 @@ export {
   addSchemaToContext,
   runWithSchemaContext,
   runWithMergedSchemaContext,
-  getContext,
+  getContext2 as getContext,
   getTenantId,
   getUserId,
   hasContext,
@@ -17136,8 +17433,11 @@ export {
   GlobalSearchService,
   PermissionService,
   ViewService,
+  seedRegistryViews,
   syncNativeViews,
+  verifyRegistryViewsSeeded,
   verifyNativeViewsSync,
+  getViewSeedPreview,
   getViewSyncPreview,
   syncNativeObjects,
   verifyNativeObjectsSync,