@cosmicdrift/kumiko-framework 0.258.0 → 0.259.0

package/src/engine/__tests__/define-feature-entity-mapping.test.ts

@@ -5,11 +5,11 @@ import { createEntity, createTextField } from "../factories";
 
 const noteEntity = createEntity({
   table: "dfm_notes",
-  fields: { title: createTextField({ required: true }) },
+  fields: { title: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 const tagEntity = createEntity({
   table: "dfm_tags",
-  fields: { label: createTextField({ required: true }) },
+  fields: { label: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 
 const bareCreate = {

package/src/engine/__tests__/engine.test.ts

@@ -63,7 +63,7 @@ describe("defineFeature", () => {
         createEntity({
           table: "Users",
           fields: {
-            email: createTextField({ searchable: true }),
+            email: createTextField({ searchable: true, personal: false, reason: "test_fixture" }),
           },
         }),
       );
@@ -331,7 +331,7 @@ describe("defineFeature", () => {
 
 describe("field factories", () => {
   test("createTextField has sensible defaults", () => {
-    const field = createTextField();
+    const field = createTextField({ personal: false, reason: "test_fixture" });
     expect(field.type).toBe("text");
     expect(field.maxLength).toBe(200);
     expect(field.searchable).toBe(false);
@@ -339,7 +339,13 @@ describe("field factories", () => {
   });
 
   test("createTextField accepts overrides", () => {
-    const field = createTextField({ searchable: true, maxLength: 500, format: "email" });
+    const field = createTextField({
+      searchable: true,
+      maxLength: 500,
+      format: "email",
+      personal: false,
+      reason: "test_fixture",
+    });
     expect(field.searchable).toBe(true);
     expect(field.maxLength).toBe(500);
     expect(field.format).toBe("email");
@@ -367,7 +373,9 @@ describe("createRegistry", () => {
         "user",
         createEntity({
           table: "Users",
-          fields: { email: createTextField({ searchable: true }) },
+          fields: {
+            email: createTextField({ searchable: true, personal: false, reason: "test_fixture" }),
+          },
         }),
       );
     });
@@ -493,8 +501,12 @@ describe("createRegistry", () => {
         createEntity({
           table: "employees",
           fields: {
-            name: createTextField(),
-            salary: createTextField({ access: { write: ["Admin"] } }),
+            name: createTextField({ personal: false, reason: "test_fixture" }),
+            salary: createTextField({
+              access: { write: ["Admin"] },
+              personal: false,
+              reason: "test_fixture",
+            }),
           },
         }),
       );
@@ -509,7 +521,13 @@ describe("createRegistry", () => {
 
   test("allows unmapped write handlers when feature has no field-access rules", () => {
     const feature = defineFeature("admin", (r) => {
-      r.entity("setting", createEntity({ table: "settings", fields: { key: createTextField() } }));
+      r.entity(
+        "setting",
+        createEntity({
+          table: "settings",
+          fields: { key: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       // No field-access rules on entity → "reset" without entity prefix is fine
       r.writeHandler("reset", z.object({}), async () => ({ isSuccess: true, data: null }), {
         access: { openToAll: true },
@@ -526,8 +544,12 @@ describe("createRegistry", () => {
         createEntity({
           table: "employees",
           fields: {
-            name: createTextField(),
-            salary: createTextField({ access: { write: ["Admin"] } }),
+            name: createTextField({ personal: false, reason: "test_fixture" }),
+            salary: createTextField({
+              access: { write: ["Admin"] },
+              personal: false,
+              reason: "test_fixture",
+            }),
           },
         }),
       );
@@ -553,7 +575,11 @@ describe("createRegistry", () => {
         createEntity({
           table: "employees",
           fields: {
-            salary: createTextField({ access: { read: ["Admin"] } }),
+            salary: createTextField({
+              access: { read: ["Admin"] },
+              personal: false,
+              reason: "test_fixture",
+            }),
           },
         }),
       );
@@ -580,7 +606,11 @@ describe("createRegistry", () => {
         createEntity({
           table: "employees",
           fields: {
-            salary: createTextField({ access: { read: ["Admin"] } }),
+            salary: createTextField({
+              access: { read: ["Admin"] },
+              personal: false,
+              reason: "test_fixture",
+            }),
           },
         }),
       );
@@ -610,9 +640,13 @@ describe("createRegistry", () => {
         createEntity({
           table: "Users",
           fields: {
-            email: createTextField({ searchable: true }),
-            firstName: createTextField(),
-            lastName: createTextField({ searchable: true }),
+            email: createTextField({ searchable: true, personal: false, reason: "test_fixture" }),
+            firstName: createTextField({ personal: false, reason: "test_fixture" }),
+            lastName: createTextField({
+              searchable: true,
+              personal: false,
+              reason: "test_fixture",
+            }),
             isEnabled: createBooleanField(),
           },
         }),
@@ -628,14 +662,17 @@ describe("createRegistry", () => {
     const feature = defineFeature("crm", (r) => {
       r.entity(
         "customer",
-        createEntity({ table: "Customers", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Customers",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.entity(
         "order",
         createEntity({
           table: "Orders",
           fields: {
-            note: createTextField({ searchable: true }),
+            note: createTextField({ searchable: true, personal: false, reason: "test_fixture" }),
             customerId: {
               type: "reference",
               entity: "customer",
@@ -662,7 +699,10 @@ describe("createRegistry", () => {
     const feature = defineFeature("crm", (r) => {
       r.entity(
         "customer",
-        createEntity({ table: "Customers", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Customers",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.entity(
         "order",
@@ -680,7 +720,13 @@ describe("createRegistry", () => {
 
   test("throws at boot when searchable is combined with multiple on a reference field (fw#2660)", () => {
     const feature = defineFeature("crm", (r) => {
-      r.entity("tag", createEntity({ table: "Tags", fields: { name: createTextField() } }));
+      r.entity(
+        "tag",
+        createEntity({
+          table: "Tags",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.entity(
         "post",
         createEntity({
@@ -705,14 +751,17 @@ describe("createRegistry", () => {
     const feature = defineFeature("crm", (r) => {
       r.entity(
         "customer",
-        createEntity({ table: "Customers", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Customers",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.entity(
         "order",
         createEntity({
           table: "Orders",
           fields: {
-            note: createTextField({ sortable: true }),
+            note: createTextField({ sortable: true, personal: false, reason: "test_fixture" }),
             customerId: {
               type: "reference",
               entity: "customer",
@@ -736,7 +785,13 @@ describe("createRegistry", () => {
 
   test("resolves a cross-feature sortable reference to its bare entity name (fw#2741)", () => {
     const users = defineFeature("users", (r) => {
-      r.entity("user", createEntity({ table: "Users", fields: { email: createTextField() } }));
+      r.entity(
+        "user",
+        createEntity({
+          table: "Users",
+          fields: { email: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
     });
     const crm = defineFeature("crm", (r) => {
       r.entity(
@@ -765,7 +820,10 @@ describe("createRegistry", () => {
     const feature = defineFeature("crm", (r) => {
       r.entity(
         "customer",
-        createEntity({ table: "Customers", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Customers",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.entity(
         "order",
@@ -785,7 +843,10 @@ describe("createRegistry", () => {
     const feature = defineFeature("crm", (r) => {
       r.entity(
         "customer",
-        createEntity({ table: "Customers", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Customers",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.entity(
         "order",
@@ -808,7 +869,13 @@ describe("createRegistry", () => {
 
   test("throws at boot when sortable is combined with multiple on a reference field (fw#2741)", () => {
     const feature = defineFeature("crm", (r) => {
-      r.entity("tag", createEntity({ table: "Tags", fields: { name: createTextField() } }));
+      r.entity(
+        "tag",
+        createEntity({
+          table: "Tags",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.entity(
         "post",
         createEntity({
@@ -883,12 +950,12 @@ describe("entity options", () => {
 
 describe("sortable fields", () => {
   test("createTextField supports sortable property", () => {
-    const field = createTextField({ sortable: true });
+    const field = createTextField({ sortable: true, personal: false, reason: "test_fixture" });
     expect(field.sortable).toBe(true);
   });
 
   test("sortable defaults to false", () => {
-    const field = createTextField();
+    const field = createTextField({ personal: false, reason: "test_fixture" });
     expect(field.sortable).toBe(false);
   });
 
@@ -899,9 +966,9 @@ describe("sortable fields", () => {
         createEntity({
           table: "Items",
           fields: {
-            name: createTextField({ sortable: true }),
-            email: createTextField(),
-            rank: createTextField({ sortable: true }),
+            name: createTextField({ sortable: true, personal: false, reason: "test_fixture" }),
+            email: createTextField({ personal: false, reason: "test_fixture" }),
+            rank: createTextField({ sortable: true, personal: false, reason: "test_fixture" }),
           },
         }),
       );
@@ -984,7 +1051,13 @@ describe("createApp", () => {
 
   test("softDeleteDefault is true by default, configurable via softDelete", () => {
     const feature = defineFeature("test", (r) => {
-      r.entity("item", createEntity({ table: "Items", fields: { name: createTextField() } }));
+      r.entity(
+        "item",
+        createEntity({
+          table: "Items",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
     });
 
     const app1 = createApp({ roles: ["Admin"], features: [feature] });
@@ -1319,7 +1392,7 @@ describe("createApp", () => {
         createEntity({
           table: "Invoices",
           fields: {
-            title: createTextField(),
+            title: createTextField({ personal: false, reason: "test_fixture" }),
             lines: createEmbeddedListField(
               { amount: { type: "money" } },
               { totalsMatch: { amount: "title" } },
@@ -1403,7 +1476,7 @@ describe("createApp", () => {
         "doc",
         createEntity({
           table: "Docs",
-          fields: { title: createTextField() },
+          fields: { title: createTextField({ personal: false, reason: "test_fixture" }) },
           transitions: {
             title: { a: ["b"] },
           },
@@ -1443,7 +1516,7 @@ describe("createApp", () => {
         "doc",
         createEntity({
           table: "Docs",
-          fields: { title: createTextField() },
+          fields: { title: createTextField({ personal: false, reason: "test_fixture" }) },
           transitions: {
             nonExistent: { a: ["b"] },
           },
@@ -1794,11 +1867,17 @@ describe("r.relation()", () => {
     const feature = defineFeature("test", (r) => {
       r.entity(
         "user",
-        createEntity({ table: "Users", fields: { departmentId: createTextField() } }),
+        createEntity({
+          table: "Users",
+          fields: { departmentId: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.entity(
         "department",
-        createEntity({ table: "Departments", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Departments",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       r.relation("user", "department", {
         type: "belongsTo",
@@ -1814,7 +1893,13 @@ describe("r.relation()", () => {
   test("registers manyToMany relation", () => {
     const feature = defineFeature("test", (r) => {
       r.entity("user", createEntity({ table: "Users", fields: {} }));
-      r.entity("role", createEntity({ table: "Roles", fields: { name: createTextField() } }));
+      r.entity(
+        "role",
+        createEntity({
+          table: "Roles",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.relation("user", "roles", {
         type: "manyToMany",
         target: "role",
@@ -1848,7 +1933,13 @@ describe("registry relations", () => {
   test("getRelations returns relations within same feature", () => {
     const f1 = defineFeature("users", (r) => {
       r.entity("user", createEntity({ table: "Users", fields: {} }));
-      r.entity("role", createEntity({ table: "Roles", fields: { name: createTextField() } }));
+      r.entity(
+        "role",
+        createEntity({
+          table: "Roles",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.relation("user", "roles", {
         type: "manyToMany",
         target: "role",

package/src/engine/__tests__/entity-handlers.test.ts

@@ -24,15 +24,15 @@ const VALID_UUID = "00000000-0000-4000-8000-000000000001";
 const noteEntity = createEntity({
   table: "notes",
   fields: {
-    title: createTextField({ required: true }),
-    body: createTextField(),
+    title: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    body: createTextField({ personal: false, reason: "test_fixture" }),
   },
 });
 
 const noteEntitySoftDelete = createEntity({
   table: "notes_soft",
   fields: {
-    title: createTextField({ required: true }),
+    title: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
   softDelete: true,
 });

package/src/engine/__tests__/entity-presave-wiring.integration.test.ts

@@ -13,9 +13,9 @@ import { from } from "../ownership";
 const contactEntity = createEntity({
   table: "presave_wiring_contacts",
   fields: {
-    firstName: createTextField({ required: true }),
-    lastName: createTextField({ required: true }),
-    displayName: createTextField(),
+    firstName: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    lastName: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    displayName: createTextField({ personal: false, reason: "test_fixture" }),
     // authorId is never set by the client — only deriveAuthorId (a preSave
     // hook) writes it. secretNote's ownership rule checks authorId, so
     // create only succeeds if the hook ran BEFORE the field-ownership check
@@ -64,7 +64,7 @@ const contactFeature = defineFeature("presave-wiring", (r) => {
 
 const throwingEntity = createEntity({
   table: "presave_wiring_throwing",
-  fields: { name: createTextField({ required: true }) },
+  fields: { name: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 
 const throwingFeature = defineFeature("presave-wiring-throw", (r) => {

package/src/engine/__tests__/entity-restore-tenant-isolation.integration.test.ts

@@ -33,7 +33,7 @@ const thingEntity = createEntity({
   table: "ctrestore_things",
   softDelete: true,
   fields: {
-    label: createTextField({ required: true }),
+    label: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
   access: { write: { Admin: "all", SystemAdmin: from("user:tenantId", "tenantId") } },
 });

package/src/engine/__tests__/entity-write-crosstenant.integration.test.ts

@@ -38,7 +38,7 @@ import {
 const thingEntity = createEntity({
   table: "ctwrite_things",
   fields: {
-    label: createTextField({ required: true }),
+    label: createTextField({ required: true, personal: false, reason: "test_fixture" }),
   },
   access: { write: { Admin: "all", SystemAdmin: from("user:tenantId", "tenantId") } },
 });

package/src/engine/__tests__/extend-entity-projection.test.ts

@@ -11,7 +11,7 @@ import { createRegistry } from "../registry";
 function exampleEntity(name = "unit") {
   return createEntity({
     table: name,
-    fields: { name: createTextField() },
+    fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
   });
 }
 

package/src/engine/__tests__/extends-registrar.test.ts

@@ -85,7 +85,7 @@ describe("extendsRegistrar", () => {
         "vehicle",
         createEntity({
           table: "Vehicles",
-          fields: { name: createTextField() },
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
         }),
       );
       r.useExtension("customFields", "vehicle");
@@ -108,7 +108,13 @@ describe("extendsRegistrar", () => {
     });
     const consumer = defineFeature("credit", (r) => {
       r.requires("audit");
-      r.entity("credit", createEntity({ table: "Credits", fields: { name: createTextField() } }));
+      r.entity(
+        "credit",
+        createEntity({
+          table: "Credits",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.writeHandler("create", z.object({ name: z.string() }), async () => ({
         isSuccess: true as const,
         data: { id: "c1" },
@@ -134,7 +140,11 @@ describe("extendsRegistrar", () => {
     const consumer = defineFeature("fleet", (r) => {
       r.entity(
         "vehicle",
-        createEntity({ table: "Vehicles", idType: "uuid", fields: { name: createTextField() } }),
+        createEntity({
+          table: "Vehicles",
+          idType: "uuid",
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
       );
       // Explicit handlers — the entity mapping is inferred from the
       // "vehicle:" prefix via tryMapEntity, so the extension's preSave

package/src/engine/__tests__/factories-long-text.test.ts

@@ -23,7 +23,7 @@ describe("createLongTextField — runtime shape", () => {
   });
 
   test("required: true is preserved as literal in the return type", () => {
-    const f = createLongTextField({ required: true });
+    const f = createLongTextField({ required: true, personal: false, reason: "test_fixture" });
     expect(f.required).toBe(true);
     // Literal-type-pin: TypeScript should narrow `required` to `true`,
     // not `boolean`. If this test compiles with `f.required: boolean`,
@@ -32,7 +32,11 @@ describe("createLongTextField — runtime shape", () => {
   });
 
   test("maxLength is propagated through", () => {
-    const f = createLongTextField({ maxLength: 1_000_000 });
+    const f = createLongTextField({
+      maxLength: 1_000_000,
+      personal: false,
+      reason: "test_fixture",
+    });
     expect(f.maxLength).toBe(1_000_000);
   });
 
@@ -55,13 +59,13 @@ describe("LongTextFieldDef — type-level non-indexable enforcement", () => {
     // back to LongTextFieldDef, the @ts-expect-error fails (because
     // the call would suddenly type-check), turning the test red.
     // @ts-expect-error sortable is NOT allowed on longText
-    const f1 = createLongTextField({ sortable: true });
+    const f1 = createLongTextField({ sortable: true, personal: false, reason: "test_fixture" });
     // @ts-expect-error searchable is NOT allowed on longText
-    const f2 = createLongTextField({ searchable: true });
+    const f2 = createLongTextField({ searchable: true, personal: false, reason: "test_fixture" });
     // @ts-expect-error filterable is NOT allowed on longText
-    const f3 = createLongTextField({ filterable: true });
+    const f3 = createLongTextField({ filterable: true, personal: false, reason: "test_fixture" });
     // @ts-expect-error format is NOT allowed on longText
-    const f4 = createLongTextField({ format: "email" });
+    const f4 = createLongTextField({ format: "email", personal: false, reason: "test_fixture" });
 
     // Runtime sanity: trotz der @ts-expect-error-ignored options ist
     // das field zur Laufzeit erfolgreich erzeugt — type-level-blockade

package/src/engine/__tests__/feature-crud-shorthand.test.ts

@@ -4,7 +4,7 @@ import { createEntity, createTextField } from "../factories";
 
 const taskEntity = createEntity({
   table: "crud_shorthand_tasks",
-  fields: { title: createTextField({ required: true }) },
+  fields: { title: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
   softDelete: true,
 });
 

package/src/engine/__tests__/feature-crud-verb-access.integration.test.ts

@@ -6,7 +6,7 @@ import { createEntity, createTextField } from "../factories";
 
 const propertyEntity = createEntity({
   table: "crud_verb_access_properties",
-  fields: { title: createTextField({ required: true }) },
+  fields: { title: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
   softDelete: true,
 });
 

package/src/engine/__tests__/multiselect-filter.integration.test.ts

@@ -15,7 +15,7 @@ import { createEntity, createMultiSelectField, createTextField } from "../factor
 const equipmentEntity = createEntity({
   table: "ms_filter_equipment",
   fields: {
-    name: createTextField({ required: true }),
+    name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
     tags: createMultiSelectField({
       options: ["vip", "urgent", "loaner"] as const,
       filterable: true,

package/src/engine/__tests__/nav.test.ts

@@ -12,7 +12,7 @@ function validateBoot(features: Parameters<typeof validateBootRaw>[0]): void {
 function productEntity() {
   return createEntity({
     table: "products",
-    fields: { name: createTextField() },
+    fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
   });
 }
 

package/src/engine/__tests__/pipeline-handler.integration.test.ts

@@ -170,7 +170,7 @@ const logHandler = defineWriteHandler({
 // unsafeProjection.* that targets it).
 const widgetEntity = createEntity({
   table: "pipeline_widget",
-  fields: { label: createTextField({ required: true }) },
+  fields: { label: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 const widgetTable = buildEntityTable("widget", widgetEntity);
 const widgetExecutor = createEventStoreExecutor(widgetTable, widgetEntity, {

package/src/engine/__tests__/pipeline-observability.integration.test.ts

@@ -52,7 +52,7 @@ const observedHandler = defineWriteHandler({
 
 const obsEntity = createEntity({
   table: "obs_smoke_things",
-  fields: { label: createTextField({ required: true }) },
+  fields: { label: createTextField({ required: true, personal: false, reason: "test_fixture" }) },
 });
 
 const obsFeature = defineFeature("obstest", (r) => {

package/src/engine/__tests__/pipeline-performance.integration.test.ts

@@ -62,7 +62,7 @@ const trivialFreeform = defineWriteHandler({
 const productEntity = createEntity({
   table: "perf_smoke_products",
   fields: {
-    sku: createTextField({ required: true }),
+    sku: createTextField({ required: true, personal: false, reason: "test_fixture" }),
     qty: createNumberField({ default: 0 }),
   },
 });

package/src/engine/__tests__/projection-detail-actions.test.ts

@@ -87,7 +87,12 @@ describe("validateBoot — projectionDetail actions (fw#2166)", () => {
 
   test("navigate action with params targeting an entityEdit of the SAME entity (via detailFor) throws — params are a no-op on an update target (review finding 3b)", () => {
     const feature = defineFeature("app", (r) => {
-      r.entity("rent", createEntity({ fields: { name: createTextField() } }));
+      r.entity(
+        "rent",
+        createEntity({
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.screen({
         id: "rent-detail",
         type: "projectionDetail",

package/src/engine/__tests__/projection-detail-singleton.test.ts

@@ -39,7 +39,12 @@ describe("validateBoot — projectionDetail singleton (fw#2312)", () => {
 
   test("singleton + detailFor throws", () => {
     const feature = defineFeature("app", (r) => {
-      r.entity("user", createEntity({ fields: { name: createTextField() } }));
+      r.entity(
+        "user",
+        createEntity({
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.queryHandler("me", z.object({}), async () => ({ id: "u1" }), {
         access: { openToAll: true },
       });

package/src/engine/__tests__/projection-detail-tabs.test.ts

@@ -100,7 +100,12 @@ describe("validateBoot — projectionDetail tabs (fw record-layout)", () => {
 
   test("mode: tabs on entityEdit throws — tabs are projectionDetail-only", () => {
     const feature = defineFeature("app", (r) => {
-      r.entity("rent", createEntity({ fields: { name: createTextField() } }));
+      r.entity(
+        "rent",
+        createEntity({
+          fields: { name: createTextField({ personal: false, reason: "test_fixture" }) },
+        }),
+      );
       r.screen({
         id: "rent-edit",
         type: "entityEdit",

package/src/engine/__tests__/projection-list-filter.integration.test.ts

@@ -22,8 +22,13 @@ import { createEntity, createTextField } from "../factories";
 const memberEntity = createEntity({
   table: "pl_filter_members",
   fields: {
-    name: createTextField({ required: true }),
-    status: createTextField({ required: true, filterable: true }),
+    name: createTextField({ required: true, personal: false, reason: "test_fixture" }),
+    status: createTextField({
+      required: true,
+      filterable: true,
+      personal: false,
+      reason: "test_fixture",
+    }),
   },
 });