@company-semantics/contracts 9.0.0 → 9.2.0

package/src/org/__tests__/org-units.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect } from "vitest";
 import {
   OrgUnitSchema,
   OrgUnitTreeNodeSchema,
@@ -14,70 +14,79 @@ import {
   OrgUnitMembershipSourceSchema,
   OrgUnitPermissionsEntrySchema,
   ListOrgUnitPermissionsResponseSchema,
-} from '../schemas.js';
+} from "../schemas.js";
 
-const UUID_A = '11111111-1111-4111-8111-111111111111';
-const UUID_B = '22222222-2222-4222-8222-222222222222';
-const UUID_C = '33333333-3333-4333-8333-333333333333';
+const UUID_A = "11111111-1111-4111-8111-111111111111";
+const UUID_B = "22222222-2222-4222-8222-222222222222";
+const UUID_C = "33333333-3333-4333-8333-333333333333";
 
 const makeUnit = (overrides: Record<string, unknown> = {}) => ({
   id: UUID_A,
   orgId: UUID_B,
   parentId: UUID_C,
-  slug: 'engineering',
-  name: 'Engineering',
+  slug: "engineering",
+  name: "Engineering",
   description: null,
-  typeTag: 'department',
-  classification: 'org_container',
-  orderKey: 'a0',
-  path: `${UUID_B.replace(/-/g, '_')}.${UUID_A.replace(/-/g, '_')}`,
-  syncMode: 'manual_only',
+  typeTag: "department",
+  classification: "org_container",
+  orderKey: "a0",
+  path: `${UUID_B.replace(/-/g, "_")}.${UUID_A.replace(/-/g, "_")}`,
+  syncMode: "manual_only",
   visibilityDefault: null,
   metadata: {},
   archivedAt: null,
-  createdAt: '2026-04-17T00:00:00Z',
-  updatedAt: '2026-04-17T00:00:00Z',
+  createdAt: "2026-04-17T00:00:00Z",
+  updatedAt: "2026-04-17T00:00:00Z",
   ...overrides,
 });
 
-describe('OrgUnitSchema', () => {
-  it('accepts a complete unit', () => {
+describe("OrgUnitSchema", () => {
+  it("accepts a complete unit", () => {
     const parsed = OrgUnitSchema.parse(makeUnit());
     expect(parsed.id).toBe(UUID_A);
-    expect(parsed.typeTag).toBe('department');
+    expect(parsed.typeTag).toBe("department");
   });
 
-  it('accepts a root unit with null parentId', () => {
-    const root = makeUnit({ parentId: null, slug: 'company', name: 'Company', typeTag: 'company' });
+  it("accepts a root unit with null parentId", () => {
+    const root = makeUnit({
+      parentId: null,
+      slug: "company",
+      name: "Company",
+      typeTag: "company",
+    });
     expect(() => OrgUnitSchema.parse(root)).not.toThrow();
   });
 
-  it('accepts archived unit (archivedAt non-null)', () => {
-    const archived = makeUnit({ archivedAt: '2026-04-17T12:00:00Z' });
+  it("accepts archived unit (archivedAt non-null)", () => {
+    const archived = makeUnit({ archivedAt: "2026-04-17T12:00:00Z" });
     expect(() => OrgUnitSchema.parse(archived)).not.toThrow();
   });
 
-  it('rejects invalid UUID for id', () => {
-    expect(() => OrgUnitSchema.parse(makeUnit({ id: 'not-a-uuid' }))).toThrow();
+  it("rejects invalid UUID for id", () => {
+    expect(() => OrgUnitSchema.parse(makeUnit({ id: "not-a-uuid" }))).toThrow();
   });
 
-  it('rejects invalid classification', () => {
-    expect(() => OrgUnitSchema.parse(makeUnit({ classification: 'bogus' }))).toThrow();
+  it("rejects invalid classification", () => {
+    expect(() =>
+      OrgUnitSchema.parse(makeUnit({ classification: "bogus" })),
+    ).toThrow();
   });
 
-  it('rejects missing required fields', () => {
+  it("rejects missing required fields", () => {
     const { name: _name, ...missingName } = makeUnit();
     expect(() => OrgUnitSchema.parse(missingName)).toThrow();
   });
 
-  it('round-trips unknown metadata fields verbatim', () => {
-    const parsed = OrgUnitSchema.parse(makeUnit({ metadata: { legacy_team_id: UUID_C } }));
+  it("round-trips unknown metadata fields verbatim", () => {
+    const parsed = OrgUnitSchema.parse(
+      makeUnit({ metadata: { legacy_team_id: UUID_C } }),
+    );
     expect(parsed.metadata).toEqual({ legacy_team_id: UUID_C });
   });
 });
 
-describe('OrgUnitTreeNodeSchema', () => {
-  it('requires depth 1..5', () => {
+describe("OrgUnitTreeNodeSchema", () => {
+  it("requires depth 1..5", () => {
     const base = {
       ...makeUnit(),
       depth: 3,
@@ -91,175 +100,201 @@ describe('OrgUnitTreeNodeSchema', () => {
   });
 });
 
-describe('OrgUnitMembershipSchema', () => {
-  it('enforces role + status + source enums', () => {
+describe("OrgUnitMembershipSchema", () => {
+  it("enforces role + status + source enums", () => {
     const membership = {
       id: UUID_A,
       orgId: UUID_B,
       unitId: UUID_C,
       userId: UUID_A,
-      membershipRole: 'l1_unit_owner',
-      status: 'active',
-      source: 'google_groups',
-      sourceRef: 'eng@example.com',
-      createdAt: '2026-04-17T00:00:00Z',
-      updatedAt: '2026-04-17T00:00:00Z',
+      membershipRole: "l1_unit_owner",
+      status: "active",
+      source: "google_groups",
+      sourceRef: "eng@example.com",
+      createdAt: "2026-04-17T00:00:00Z",
+      updatedAt: "2026-04-17T00:00:00Z",
     };
     expect(() => OrgUnitMembershipSchema.parse(membership)).not.toThrow();
     expect(() =>
-      OrgUnitMembershipSchema.parse({ ...membership, membershipRole: 'root' })
+      OrgUnitMembershipSchema.parse({ ...membership, membershipRole: "root" }),
+    ).toThrow();
+    expect(() =>
+      OrgUnitMembershipSchema.parse({ ...membership, status: "terminated" }),
     ).toThrow();
-    expect(() => OrgUnitMembershipSchema.parse({ ...membership, status: 'terminated' })).toThrow();
   });
 });
 
-describe('OrgUnitRelationshipSchema', () => {
-  it('accepts graph edge with nullable contextKey', () => {
+describe("OrgUnitRelationshipSchema", () => {
+  it("accepts graph edge with nullable contextKey", () => {
     const edge = {
       id: UUID_A,
       orgId: UUID_B,
       fromUnit: UUID_C,
       toUnit: UUID_A,
-      type: 'collaborates_with' as const,
-      role: 'participant' as const,
+      type: "collaborates_with" as const,
+      role: "participant" as const,
       contextKey: null,
       metadata: {},
-      createdAt: '2026-04-17T00:00:00Z',
+      createdAt: "2026-04-17T00:00:00Z",
     };
     expect(() => OrgUnitRelationshipSchema.parse(edge)).not.toThrow();
     expect(() =>
-      OrgUnitRelationshipSchema.parse({ ...edge, contextKey: 'infra-context' })
+      OrgUnitRelationshipSchema.parse({ ...edge, contextKey: "infra-context" }),
     ).not.toThrow();
   });
 });
 
-describe('OrgLevelConfigSchema', () => {
-  it('enforces depth 1..5, non-empty-when-present label/labelPlural, and icon enum', () => {
+describe("OrgLevelConfigSchema", () => {
+  it("enforces depth 1..5, non-empty-when-present label/labelPlural, and icon enum", () => {
     const entry = {
       orgId: UUID_B,
       depth: 2,
-      label: 'Department',
-      labelPlural: 'Departments',
-      icon: 'users-four' as const,
-      createdAt: '2026-04-17T00:00:00Z',
-      updatedAt: '2026-04-17T00:00:00Z',
+      label: "Department",
+      labelPlural: "Departments",
+      icon: "users-four" as const,
+      createdAt: "2026-04-17T00:00:00Z",
+      updatedAt: "2026-04-17T00:00:00Z",
     };
     expect(() => OrgLevelConfigSchema.parse(entry)).not.toThrow();
     expect(() =>
-      OrgLevelConfigSchema.parse({ ...entry, label: null, labelPlural: null, icon: null })
+      OrgLevelConfigSchema.parse({
+        ...entry,
+        label: null,
+        labelPlural: null,
+        icon: null,
+      }),
     ).not.toThrow();
     expect(() => OrgLevelConfigSchema.parse({ ...entry, depth: 6 })).toThrow();
-    expect(() => OrgLevelConfigSchema.parse({ ...entry, label: '' })).toThrow();
-    expect(() => OrgLevelConfigSchema.parse({ ...entry, labelPlural: '' })).toThrow();
+    expect(() => OrgLevelConfigSchema.parse({ ...entry, label: "" })).toThrow();
+    expect(() =>
+      OrgLevelConfigSchema.parse({ ...entry, labelPlural: "" }),
+    ).toThrow();
     expect(() =>
-      OrgLevelConfigSchema.parse({ ...entry, icon: 'not-an-icon' })
+      OrgLevelConfigSchema.parse({ ...entry, icon: "not-an-icon" }),
     ).toThrow();
   });
 });
 
-describe('Response schemas', () => {
-  it('OrgUnitTreeResponseSchema accepts empty tree', () => {
+describe("Response schemas", () => {
+  it("OrgUnitTreeResponseSchema accepts empty tree", () => {
     expect(() =>
       OrgUnitTreeResponseSchema.parse({
         nodes: [],
         levelConfig: [],
-      })
+      }),
     ).not.toThrow();
   });
 
-  it('OrgUnitChildrenResponseSchema wraps parentId + children array', () => {
+  it("OrgUnitChildrenResponseSchema wraps parentId + children array", () => {
     expect(() =>
-      OrgUnitChildrenResponseSchema.parse({ parentId: UUID_A, children: [] })
+      OrgUnitChildrenResponseSchema.parse({ parentId: UUID_A, children: [] }),
     ).not.toThrow();
   });
 
-  it('OrgUnitRelationshipsResponseSchema has incoming + outgoing arrays', () => {
+  it("OrgUnitRelationshipsResponseSchema has incoming + outgoing arrays", () => {
     expect(() =>
       OrgUnitRelationshipsResponseSchema.parse({
         unitId: UUID_A,
         incoming: [],
         outgoing: [],
-      })
+      }),
     ).not.toThrow();
   });
 });
 
-describe('Enum exhaustiveness', () => {
-  it('OrgUnitErrorCodeSchema enumerates all 10 known codes', () => {
+describe("Enum exhaustiveness", () => {
+  it("OrgUnitErrorCodeSchema enumerates all 10 known codes", () => {
     const codes = [
-      'CYCLE_BLOCKED',
-      'DEPTH_EXCEEDED',
-      'TARGET_ARCHIVED',
-      'ROOT_HAS_NO_PARENT',
-      'PARENT_ARCHIVED',
-      'SLUG_TAKEN',
-      'CROSS_ORG_REPARENT',
-      'ORDERKEY_CONFLICT',
-      'SIBLING_NOT_FOUND',
-      'SIBLINGS_DIFFERENT_PARENT',
+      "CYCLE_BLOCKED",
+      "DEPTH_EXCEEDED",
+      "TARGET_ARCHIVED",
+      "ROOT_HAS_NO_PARENT",
+      "PARENT_ARCHIVED",
+      "SLUG_TAKEN",
+      "CROSS_ORG_REPARENT",
+      "ORDERKEY_CONFLICT",
+      "SIBLING_NOT_FOUND",
+      "SIBLINGS_DIFFERENT_PARENT",
     ];
     for (const code of codes) {
       expect(() => OrgUnitErrorCodeSchema.parse(code)).not.toThrow();
     }
-    expect(() => OrgUnitErrorCodeSchema.parse('OTHER')).toThrow();
+    expect(() => OrgUnitErrorCodeSchema.parse("OTHER")).toThrow();
   });
 
-  it('classification enum matches backend _enums.ts', () => {
-    for (const v of ['execution_unit', 'org_container', 'custom']) {
+  it("classification enum matches backend _enums.ts", () => {
+    for (const v of ["execution_unit", "org_container", "custom"]) {
       expect(() => OrgUnitClassificationSchema.parse(v)).not.toThrow();
     }
   });
 
-  it('relationship type enum matches backend', () => {
-    for (const v of ['collaborates_with', 'reports_to', 'depends_on', 'custom']) {
+  it("relationship type enum matches backend", () => {
+    for (const v of [
+      "collaborates_with",
+      "reports_to",
+      "depends_on",
+      "custom",
+    ]) {
       expect(() => OrgUnitRelationshipTypeSchema.parse(v)).not.toThrow();
     }
   });
 
-  it('membership source enum matches backend', () => {
-    for (const v of ['manual', 'google_groups', 'scim', 'hris']) {
+  it("membership source enum matches backend", () => {
+    for (const v of ["manual", "google_groups", "scim", "hris"]) {
       expect(() => OrgUnitMembershipSourceSchema.parse(v)).not.toThrow();
     }
   });
 });
 
-describe('OrgUnitPermissionsEntrySchema', () => {
+describe("OrgUnitPermissionsEntrySchema", () => {
   const entry = {
     userId: UUID_A,
-    membershipRole: 'l1_unit_owner' as const,
+    membershipRole: "l1_unit_owner" as const,
     inheritedFromUnitId: UUID_C,
-    inheritedFromUnitName: 'Engineering',
+    inheritedFromUnitName: "Engineering",
   };
 
-  it('accepts a well-formed entry', () => {
+  it("accepts a well-formed entry", () => {
     expect(() => OrgUnitPermissionsEntrySchema.parse(entry)).not.toThrow();
   });
 
-  it('rejects invalid membershipRole', () => {
+  it("rejects invalid membershipRole", () => {
     expect(() =>
-      OrgUnitPermissionsEntrySchema.parse({ ...entry, membershipRole: 'member' })
+      OrgUnitPermissionsEntrySchema.parse({
+        ...entry,
+        membershipRole: "member",
+      }),
     ).not.toThrow();
     expect(() =>
-      OrgUnitPermissionsEntrySchema.parse({ ...entry, membershipRole: 'bogus' })
+      OrgUnitPermissionsEntrySchema.parse({
+        ...entry,
+        membershipRole: "bogus",
+      }),
     ).toThrow();
   });
 
-  it('requires UUIDs for user and inherited unit', () => {
+  it("requires UUIDs for user and inherited unit", () => {
     expect(() =>
-      OrgUnitPermissionsEntrySchema.parse({ ...entry, userId: 'nope' })
+      OrgUnitPermissionsEntrySchema.parse({ ...entry, userId: "nope" }),
     ).toThrow();
     expect(() =>
-      OrgUnitPermissionsEntrySchema.parse({ ...entry, inheritedFromUnitId: 'nope' })
+      OrgUnitPermissionsEntrySchema.parse({
+        ...entry,
+        inheritedFromUnitId: "nope",
+      }),
     ).toThrow();
   });
 
-  it('rejects empty inheritedFromUnitName', () => {
+  it("rejects empty inheritedFromUnitName", () => {
     expect(() =>
-      OrgUnitPermissionsEntrySchema.parse({ ...entry, inheritedFromUnitName: '' })
+      OrgUnitPermissionsEntrySchema.parse({
+        ...entry,
+        inheritedFromUnitName: "",
+      }),
     ).toThrow();
   });
 
-  it('list response wraps entries with unitId', () => {
+  it("list response wraps entries with unitId", () => {
     const parsed = ListOrgUnitPermissionsResponseSchema.parse({
       unitId: UUID_B,
       entries: [entry],

package/src/org/__tests__/tree-ordering.test.ts

@@ -1,5 +1,5 @@
-import { describe, it, expect } from 'vitest';
-import { orderTreeNodes, type TreeOrderableNode } from '../tree-ordering.js';
+import { describe, it, expect } from "vitest";
+import { orderTreeNodes, type TreeOrderableNode } from "../tree-ordering.js";
 
 interface TestNode extends TreeOrderableNode {
   label?: string;
@@ -19,31 +19,42 @@ function shuffle<T>(input: readonly T[], seed: number): T[] {
 }
 
 const FIXTURE: TestNode[] = [
-  { id: 'root-1', parentId: null, orderKey: '10' },
-  { id: 'root-2', parentId: null, orderKey: '20' },
-  { id: 'a', parentId: 'root-1', orderKey: '20' },
-  { id: 'b', parentId: 'root-1', orderKey: '10' },
-  { id: 'c', parentId: 'root-1', orderKey: '30' },
-  { id: 'aa', parentId: 'a', orderKey: '10' },
-  { id: 'ab', parentId: 'a', orderKey: '20' },
-  { id: 'ba', parentId: 'b', orderKey: '10' },
-  { id: 'x', parentId: 'root-2', orderKey: '10' },
-  { id: 'y', parentId: 'root-2', orderKey: '10' },
+  { id: "root-1", parentId: null, orderKey: "10" },
+  { id: "root-2", parentId: null, orderKey: "20" },
+  { id: "a", parentId: "root-1", orderKey: "20" },
+  { id: "b", parentId: "root-1", orderKey: "10" },
+  { id: "c", parentId: "root-1", orderKey: "30" },
+  { id: "aa", parentId: "a", orderKey: "10" },
+  { id: "ab", parentId: "a", orderKey: "20" },
+  { id: "ba", parentId: "b", orderKey: "10" },
+  { id: "x", parentId: "root-2", orderKey: "10" },
+  { id: "y", parentId: "root-2", orderKey: "10" },
 ];
 
-describe('orderTreeNodes', () => {
-  it('emits a parent-before-children flat order sorted per parent', () => {
+describe("orderTreeNodes", () => {
+  it("emits a parent-before-children flat order sorted per parent", () => {
     const ordered = orderTreeNodes(FIXTURE).map((n) => n.id);
-    expect(ordered).toEqual(['root-1', 'b', 'ba', 'a', 'aa', 'ab', 'c', 'root-2', 'x', 'y']);
+    expect(ordered).toEqual([
+      "root-1",
+      "b",
+      "ba",
+      "a",
+      "aa",
+      "ab",
+      "c",
+      "root-2",
+      "x",
+      "y",
+    ]);
   });
 
-  it('is idempotent — running twice produces the same result', () => {
+  it("is idempotent — running twice produces the same result", () => {
     const once = orderTreeNodes(FIXTURE);
     const twice = orderTreeNodes(once);
     expect(twice).toEqual(once);
   });
 
-  it('is stable under input shuffle — order depends only on (orderKey, id), not insertion order', () => {
+  it("is stable under input shuffle — order depends only on (orderKey, id), not insertion order", () => {
     const baseline = orderTreeNodes(FIXTURE).map((n) => n.id);
     for (const seed of [1, 2, 3, 42, 1337, 999999]) {
       const shuffled = shuffle(FIXTURE, seed);
@@ -52,51 +63,60 @@ describe('orderTreeNodes', () => {
     }
   });
 
-  it('uses id as deterministic tiebreaker when orderKey is identical', () => {
+  it("uses id as deterministic tiebreaker when orderKey is identical", () => {
     const ties: TestNode[] = [
-      { id: 'zeta', parentId: null, orderKey: '50' },
-      { id: 'alpha', parentId: null, orderKey: '50' },
-      { id: 'mike', parentId: null, orderKey: '50' },
+      { id: "zeta", parentId: null, orderKey: "50" },
+      { id: "alpha", parentId: null, orderKey: "50" },
+      { id: "mike", parentId: null, orderKey: "50" },
     ];
     const order = orderTreeNodes(ties).map((n) => n.id);
-    expect(order).toEqual(['alpha', 'mike', 'zeta']);
+    expect(order).toEqual(["alpha", "mike", "zeta"]);
 
     const shuffled = orderTreeNodes(shuffle(ties, 7)).map((n) => n.id);
-    expect(shuffled).toEqual(['alpha', 'mike', 'zeta']);
+    expect(shuffled).toEqual(["alpha", "mike", "zeta"]);
   });
 
-  it('places nodes with null parentId in the root group, before any descendants', () => {
+  it("places nodes with null parentId in the root group, before any descendants", () => {
     const nodes: TestNode[] = [
-      { id: 'child-of-r2', parentId: 'r2', orderKey: '10' },
-      { id: 'r1', parentId: null, orderKey: '20' },
-      { id: 'r2', parentId: null, orderKey: '10' },
-      { id: 'child-of-r1', parentId: 'r1', orderKey: '10' },
+      { id: "child-of-r2", parentId: "r2", orderKey: "10" },
+      { id: "r1", parentId: null, orderKey: "20" },
+      { id: "r2", parentId: null, orderKey: "10" },
+      { id: "child-of-r1", parentId: "r1", orderKey: "10" },
     ];
     const ordered = orderTreeNodes(nodes).map((n) => n.id);
-    expect(ordered).toEqual(['r2', 'child-of-r2', 'r1', 'child-of-r1']);
+    expect(ordered).toEqual(["r2", "child-of-r2", "r1", "child-of-r1"]);
 
-    const roots = orderTreeNodes(nodes).filter((n) => n.parentId === null).map((n) => n.id);
-    expect(roots).toEqual(['r2', 'r1']);
+    const roots = orderTreeNodes(nodes)
+      .filter((n) => n.parentId === null)
+      .map((n) => n.id);
+    expect(roots).toEqual(["r2", "r1"]);
   });
 
-  it('preserves all input fields on the output nodes', () => {
+  it("preserves all input fields on the output nodes", () => {
     const rich: TestNode[] = [
-      { id: 'only', parentId: null, orderKey: '1', label: 'hello' },
+      { id: "only", parentId: null, orderKey: "1", label: "hello" },
     ];
     const [out] = orderTreeNodes(rich);
-    expect(out).toEqual({ id: 'only', parentId: null, orderKey: '1', label: 'hello' });
+    expect(out).toEqual({
+      id: "only",
+      parentId: null,
+      orderKey: "1",
+      label: "hello",
+    });
   });
 
-  it('returns a new array without mutating the input list', () => {
+  it("returns a new array without mutating the input list", () => {
     const input = FIXTURE.slice();
     const snapshotIds = input.map((n) => n.id);
     orderTreeNodes(input);
     expect(input.map((n) => n.id)).toEqual(snapshotIds);
   });
 
-  it('is strictly synchronous (no Promise return)', () => {
+  it("is strictly synchronous (no Promise return)", () => {
     const result = orderTreeNodes(FIXTURE);
     expect(Array.isArray(result)).toBe(true);
-    expect(typeof (result as unknown as { then?: unknown }).then).toBe('undefined');
+    expect(typeof (result as unknown as { then?: unknown }).then).toBe(
+      "undefined",
+    );
   });
 });

package/src/org/__tests__/view-scopes.test.ts

@@ -1,51 +1,51 @@
-import { describe, it, expect } from 'vitest'
-import { VIEW_SCOPE_MAP, getViewScope } from '../view-scopes.js'
+import { describe, it, expect } from "vitest";
+import { VIEW_SCOPE_MAP, getViewScope } from "../view-scopes.js";
 
-describe('VIEW_SCOPE_MAP golden snapshot', () => {
-  it('exact values are frozen', () => {
+describe("VIEW_SCOPE_MAP golden snapshot", () => {
+  it("exact values are frozen", () => {
     expect(VIEW_SCOPE_MAP).toStrictEqual({
-      workspace: 'org.view_workspace',
-      timeline: 'org.view_timeline',
-      teamwork: 'org.view_teamwork',
-      'teamwork-member': 'org.view_teamwork',
-      'company-md': 'org.view_company_md',
-      teams: 'org.view_teams',
-      'internal-admin': 'internal.view_admin',
+      workspace: "org.view_workspace",
+      timeline: "org.view_timeline",
+      teamwork: "org.view_teamwork",
+      "teamwork-member": "org.view_teamwork",
+      "company-md": "org.view_company_md",
+      teams: "org.view_teams",
+      "internal-admin": "internal.view_admin",
       chat: null,
       settings: null,
       chats: null,
-      'my-work': null,
-      'user-md': null,
+      "my-work": null,
+      "user-md": null,
       upgrade: null,
-    })
-  })
-})
+    });
+  });
+});
 
-describe('getViewScope', () => {
-  it('returns the required scope for protected views', () => {
-    expect(getViewScope('workspace')).toBe('org.view_workspace')
-    expect(getViewScope('timeline')).toBe('org.view_timeline')
-    expect(getViewScope('teamwork')).toBe('org.view_teamwork')
-    expect(getViewScope('company-md')).toBe('org.view_company_md')
-    expect(getViewScope('internal-admin')).toBe('internal.view_admin')
-  })
+describe("getViewScope", () => {
+  it("returns the required scope for protected views", () => {
+    expect(getViewScope("workspace")).toBe("org.view_workspace");
+    expect(getViewScope("timeline")).toBe("org.view_timeline");
+    expect(getViewScope("teamwork")).toBe("org.view_teamwork");
+    expect(getViewScope("company-md")).toBe("org.view_company_md");
+    expect(getViewScope("internal-admin")).toBe("internal.view_admin");
+  });
 
-  it('returns null for public views', () => {
-    expect(getViewScope('chat')).toBeNull()
-    expect(getViewScope('settings')).toBeNull()
-    expect(getViewScope('chats')).toBeNull()
-    expect(getViewScope('upgrade')).toBeNull()
-  })
+  it("returns null for public views", () => {
+    expect(getViewScope("chat")).toBeNull();
+    expect(getViewScope("settings")).toBeNull();
+    expect(getViewScope("chats")).toBeNull();
+    expect(getViewScope("upgrade")).toBeNull();
+  });
 
-  it('returns null for unknown view string', () => {
-    expect(getViewScope('nonexistent-view')).toBeNull()
-  })
+  it("returns null for unknown view string", () => {
+    expect(getViewScope("nonexistent-view")).toBeNull();
+  });
 
-  it('returns null for empty string', () => {
-    expect(getViewScope('')).toBeNull()
-  })
+  it("returns null for empty string", () => {
+    expect(getViewScope("")).toBeNull();
+  });
 
-  it('returns null for view name that is a substring of a real view', () => {
-    expect(getViewScope('work')).toBeNull()
-  })
-})
+  it("returns null for view name that is a substring of a real view", () => {
+    expect(getViewScope("work")).toBeNull();
+  });
+});