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

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

@@ -543,7 +543,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 +581,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 +702,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 +718,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 +741,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);
@@ -4000,6 +4084,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(),
@@ -4297,32 +4382,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 +4422,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 +4453,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 +4465,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 = new Set(views.map((v) => v.id));
+      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 = new Set(views.map((v) => v.id));
+      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 +4999,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 +5022,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 +5566,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 +6514,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 +6665,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 +6731,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 +6773,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 +6808,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 +6871,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 +6942,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 +6980,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 +7059,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 +7092,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 +7132,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,48 +7147,332 @@ 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)
+   */
+  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: 'detail', 'list-view', 'company-detail'\n  \u274C Invalid: 'Detail', 'listView', 'list_view'"
+    });
+    try {
+      viewNameSchema.parse(name);
+    } catch (error2) {
+      if (error2 instanceof z3.ZodError) {
+        throw new Error(`[DetailViewBuilder] ${error2.issues[0].message}`);
+      }
+      throw error2;
+    }
+  }
+};
+var ViewBuilder = DetailViewBuilder;
+function detailView(name, label) {
+  return new DetailViewBuilder(name, label);
+}
+function view(name, label) {
+  return new DetailViewBuilder(name, label);
+}
+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;
   }
   /**
-   * Validate view name format (kebab-case)
+   * Build the final view definition
    */
-  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: 'detail', 'list-view', 'company-detail'\n  \u274C Invalid: 'Detail', 'listView', 'list_view'"
-    });
-    try {
-      viewNameSchema.parse(name);
-    } catch (error2) {
-      if (error2 instanceof z3.ZodError) {
-        throw new Error(`[ViewBuilder] ${error2.issues[0].message}`);
-      }
-      throw error2;
-    }
+  build() {
+    this.view._addTab(this.tabData);
+    return this.view.build();
   }
 };
-function view(name, label) {
-  return new ViewBuilder(name, label);
+function listView(name, label) {
+  return new ListViewBuilder(name, label);
 }
 function group(id, label) {
   return new GroupBuilder(id, label);
@@ -7492,6 +8018,46 @@ 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);
+}
+function getPropertyProtectionLevel(property) {
+  if (isIdentityProperty(property)) return "identity";
+  if (isBehaviorProperty(property)) return "behavior";
+  if (isPresentationProperty(property)) return "presentation";
+  return "unknown";
+}
+function filterPropertiesByCategory(properties, category) {
+  switch (category) {
+    case "identity":
+      return properties.filter(isIdentityProperty);
+    case "behavior":
+      return properties.filter(isBehaviorProperty);
+    case "presentation":
+      return properties.filter(isPresentationProperty);
+  }
+}
+
 // src/types/errors.ts
 var RecordReferencedError = class extends Error {
   constructor(recordId, references) {
@@ -8321,7 +8887,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 +8900,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,
@@ -12231,7 +12812,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 +13077,7 @@ var WorkflowInstanceService = class extends BaseService {
         updatedAt: /* @__PURE__ */ new Date()
       };
     }
-    const executionId = randomUUID();
+    const executionId = generateId();
     let current = {
       ...instance,
       context: {
@@ -16172,124 +16752,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);
     }
-    const dbView = await this.adapter.views.findByName(objectName, viewName);
-    if (dbView) {
-      return this.convertDBViewToDefinition(dbView);
+    if (!dbView) {
+      return null;
     }
-    return null;
+    const view2 = this.convertDBViewToDefinition(dbView);
+    if (!userId) {
+      return view2;
+    }
+    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 +17096,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 +17108,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 +17118,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 +17133,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 +17143,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 && Object.keys(overlay.configOverrides).length > 0;
+  }
+  // ============================================================================
+  // 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 +17298,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 +17371,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 +17457,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([
@@ -16755,7 +17677,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 +17698,14 @@ var NoopGeocodingAdapter = class {
 };
 
 export {
+  IDENTITY_PROPERTIES,
+  BEHAVIOR_PROPERTIES,
+  PRESENTATION_PROPERTIES,
+  isIdentityProperty,
+  isBehaviorProperty,
+  isPresentationProperty,
+  getPropertyProtectionLevel,
+  filterPropertiesByCategory,
   RELATION_TARGET_ANY,
   isUniversalRelation,
   RecordReferencedError,
@@ -16919,8 +17849,13 @@ export {
   FlowsTabConfig,
   DocumentsTabConfig,
   TabBuilder,
+  DetailViewBuilder,
   ViewBuilder,
+  detailView,
   view,
+  ListViewBuilder,
+  ListViewTabConfigBuilder,
+  listView,
   group,
   WorkflowFormRowBuilder,
   WorkflowFormBuilder,
@@ -17011,6 +17946,14 @@ export {
   QueryNoResultError,
   QueryMultipleResultsError,
   TenantContextError,
+  FeatureFlagsContextError,
+  isFeatureEnabled,
+  getFeatureValue,
+  getFeatureFlags,
+  tryGetFeatureValue,
+  hasFeatureFlagsContext,
+  runWithFeatureFlags,
+  withFeatureFlags,
   getSchemaFromContext,
   getSchemaByNameFromContext,
   hasSchemaContext,
@@ -17018,7 +17961,7 @@ export {
   addSchemaToContext,
   runWithSchemaContext,
   runWithMergedSchemaContext,
-  getContext,
+  getContext2 as getContext,
   getTenantId,
   getUserId,
   hasContext,
@@ -17136,8 +18079,11 @@ export {
   GlobalSearchService,
   PermissionService,
   ViewService,
+  seedRegistryViews,
   syncNativeViews,
+  verifyRegistryViewsSeeded,
   verifyNativeViewsSync,
+  getViewSeedPreview,
   getViewSyncPreview,
   syncNativeObjects,
   verifyNativeObjectsSync,