@kelpie/server 0.8.0 → 0.9.0

package/migrations/meta/_journal.json

@@ -169,6 +169,97 @@
       "when": 1787651539093,
       "tag": "0023_funny_maddog",
       "breakpoints": true
+    },
+    {
+      "idx": 24,
+      "version": "7",
+      "when": 1787978002874,
+      "tag": "0024_third_king_cobra",
+      "breakpoints": true
+    },
+    {
+      "idx": 25,
+      "version": "7",
+      "when": 1787979321712,
+      "tag": "0025_worthless_chimera",
+      "breakpoints": true
+    },
+    {
+      "idx": 26,
+      "version": "7",
+      "when": 1787981859874,
+      "tag": "0026_late_aqueduct",
+      "breakpoints": true
+    },
+    {
+      "idx": 27,
+      "version": "7",
+      "when": 1788007470077,
+      "tag": "0027_brainy_silver_sable",
+      "breakpoints": true
+    },
+    {
+      "idx": 28,
+      "version": "7",
+      "when": 1788045423814,
+      "tag": "0028_freezing_scrambler",
+      "breakpoints": true
+    },
+    {
+      "idx": 29,
+      "version": "7",
+      "when": 1788067713235,
+      "tag": "0029_custom_fields",
+      "breakpoints": true
+    },
+    {
+      "idx": 30,
+      "version": "7",
+      "when": 1788089808149,
+      "tag": "0030_enquiries",
+      "breakpoints": true
+    },
+    {
+      "idx": 31,
+      "version": "7",
+      "when": 1788128702292,
+      "tag": "0031_consent",
+      "breakpoints": true
+    },
+    {
+      "idx": 32,
+      "version": "7",
+      "when": 1788133056653,
+      "tag": "0032_form_field_statement",
+      "breakpoints": true
+    },
+    {
+      "idx": 33,
+      "version": "7",
+      "when": 1788134204561,
+      "tag": "0033_form_field_consent_purpose_ids",
+      "breakpoints": true
+    },
+    {
+      "idx": 34,
+      "version": "7",
+      "when": 1788134239537,
+      "tag": "0034_drop_form_field_consent_purpose_id",
+      "breakpoints": true
+    },
+    {
+      "idx": 35,
+      "version": "7",
+      "when": 1788146179776,
+      "tag": "0035_form_field_consent_purpose_labels",
+      "breakpoints": true
+    },
+    {
+      "idx": 36,
+      "version": "7",
+      "when": 1788146891073,
+      "tag": "0036_form_field_notice_type",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kelpie/server",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "The Kelpie service as a library: module runtime, core CRM modules, REST API, MCP surface, and the shared migration pipeline.",
   "keywords": [
     "kelpie",
@@ -52,7 +52,7 @@
   },
   "dependencies": {
     "@hono/node-server": "^2.0.12",
-    "@kelpie/schemas": "^0.8.0",
+    "@kelpie/schemas": "^0.9.0",
     "@node-rs/argon2": "^2.0.2",
     "drizzle-orm": "^0.45.2",
     "emittery": "^2.0.0",

package/src/lib/ids.ts

@@ -19,6 +19,7 @@ export const idPrefixes = {
   position: 'pos',
   pipelineStage: 'stage',
   deal: 'deal',
+  enquiry: 'enq',
   opportunity: 'opp',
   partnership: 'prt',
   raise: 'rse',
@@ -30,7 +31,17 @@ export const idPrefixes = {
   activity: 'act',
   list: 'list',
   listMember: 'lmem',
+  /**
+   * Never returns over the wire either: `person_links` has no routes of its
+   * own — the link surfaces as a `person_ids` array on each pipeline record —
+   * so the prefix is not in `api.md`'s public prefix table, matching `idem`
+   * and `rl`. It still comes from this factory rather than a bare ULID call,
+   * so every id in the database is generated the same, injectable way.
+   */
+  personLink: 'plink',
   handbookPage: 'hb',
+  customFieldDefinition: 'fld',
+  consentPurpose: 'cnp',
   form: 'form',
   formField: 'ff',
   formSubmission: 'sub',

package/src/modules/activities/repository.ts

@@ -1,12 +1,16 @@
 import { and, eq, inArray, or, sql } from 'drizzle-orm'
 import type { SQL } from 'drizzle-orm'
 
+import type { PipelineKind } from '@kelpie/schemas'
+
 import { keysetCondition, orderByWindow, timestampSort } from '../../lib/pagination.ts'
 import type { ListWindow, SortableFields } from '../../lib/pagination.ts'
 import type { Queryable } from '../../runtime/transaction.ts'
-import { dealPeople, deals } from '../deals/schema.ts'
+import { deals } from '../deals/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
 import { opportunities } from '../opportunities/schema.ts'
-import { partnershipPeople, partnerships } from '../partnerships/schema.ts'
+import { partnerships } from '../partnerships/schema.ts'
+import * as personLinks from '../personLinks.ts'
 import type { RecordTargetType } from '../recordTargets.ts'
 import { activities } from './schema.ts'
 
@@ -66,7 +70,7 @@ export async function listRolledUpTargets(
   targetId: string,
 ): Promise<ActivityTarget[]> {
   if (targetType === 'company') {
-    const [dealRows, opportunityRows, partnershipRows] = await Promise.all([
+    const [dealRows, opportunityRows, partnershipRows, enquiryRows] = await Promise.all([
       db
         .select({ id: deals.id })
         .from(deals)
@@ -81,36 +85,31 @@ export async function listRolledUpTargets(
         .select({ id: partnerships.id })
         .from(partnerships)
         .where(and(eq(partnerships.workspaceId, workspaceId), eq(partnerships.companyId, targetId))),
+      db
+        .select({ id: enquiries.id })
+        .from(enquiries)
+        .where(and(eq(enquiries.workspaceId, workspaceId), eq(enquiries.companyId, targetId))),
     ])
 
     return [
       ...dealRows.map((row) => ({ targetType: 'deal' as const, targetId: row.id })),
       ...opportunityRows.map((row) => ({ targetType: 'opportunity' as const, targetId: row.id })),
       ...partnershipRows.map((row) => ({ targetType: 'partnership' as const, targetId: row.id })),
+      ...enquiryRows.map((row) => ({ targetType: 'enquiry' as const, targetId: row.id })),
     ]
   }
 
   if (targetType === 'person') {
-    // An opportunity has no people, so a person rolls up two relations, not three.
-    const [dealRows, partnershipRows] = await Promise.all([
-      db
-        .select({ id: deals.id })
-        .from(deals)
-        .innerJoin(dealPeople, eq(dealPeople.dealId, deals.id))
-        .where(and(eq(deals.workspaceId, workspaceId), eq(dealPeople.personId, targetId))),
-      db
-        .select({ id: partnerships.id })
-        .from(partnerships)
-        .innerJoin(partnershipPeople, eq(partnershipPeople.partnershipId, partnerships.id))
-        .where(
-          and(eq(partnerships.workspaceId, workspaceId), eq(partnershipPeople.personId, targetId)),
-        ),
-    ])
-
-    return [
-      ...dealRows.map((row) => ({ targetType: 'deal' as const, targetId: row.id })),
-      ...partnershipRows.map((row) => ({ targetType: 'partnership' as const, targetId: row.id })),
-    ]
+    // person_links carries all four pipeline kinds in one table, so a person's
+    // roll-up is one read regardless of how many pipelines they touch. The
+    // shared helper's `PipelineKind` narrows to the check-constraint set, which
+    // is exactly what an ActivityTarget expects to receive.
+    const links = await personLinks.listTargetsOfPerson(db, workspaceId, targetId)
+
+    return links.map((link) => ({
+      targetType: link.targetType satisfies PipelineKind as RecordTargetType,
+      targetId: link.targetId,
+    }))
   }
 
   return []

package/src/modules/activities/wording.ts

@@ -147,6 +147,24 @@ export function describeStageChange(fromStage: string, toStage: string): Activit
   return { action: `moved to ${toStage}`, detail: `${fromStage} → ${toStage}` }
 }
 
+/**
+ * `converted to Deal`, with the deal's name beneath it. Files on the enquiry;
+ * the deal's own timeline gets `created Deal from Enquiry` via
+ * `describeCreationFrom`.
+ */
+export function describeConversion(objectLabel: string, name: string): ActivityWording {
+  return { action: `converted to ${objectLabel}`, detail: name }
+}
+
+/**
+ * `created Deal from Enquiry`, with the source record's name beneath it. Mirror
+ * of `describeCreationVia` but the source is another CRM record rather than a
+ * form or import file.
+ */
+export function describeCreationFrom(objectLabel: string, sourceLabel: string, sourceName: string): ActivityWording {
+  return { action: `created ${objectLabel} from ${sourceLabel}`, detail: sourceName }
+}
+
 /** How much of a note's body the timeline repeats before trailing off. */
 const NOTE_EXCERPT_LENGTH = 120
 

package/src/modules/agent-tasks/catalog.ts

@@ -305,6 +305,69 @@ Optionally save as a Note.`,
 Append a Note, propose Plan items, update summary/whyWin/risks only with clear evidence, extract Decisions.`,
   }),
 
+  // Enquiry
+  task({
+    id: 'enquiry.triage',
+    label: 'Triage enquiry',
+    description: 'Recommend pursue, nurture, or close.',
+    targetTypes: ['enquiry'],
+    placement: 'primary',
+    handbookSlugs: ['ideal-customer-profile', 'product', 'agent-faq'],
+    instructions: `Assess this Enquiry against Ideal customer profile and Product. Recommend one of:
+- pursue (convert to Deal)
+- nurture (keep in In progress, add a follow-up Plan item)
+- close (move to Closed, note the reason).
+Save the recommendation and rationale as a Note. Do not change the stage or convert without human confirmation.`,
+  }),
+  task({
+    id: 'enquiry.propose_plan',
+    label: 'Propose Plan',
+    description: 'Dated follow-up items.',
+    targetTypes: ['enquiry'],
+    placement: 'primary',
+    handbookSlugs: ['agent-faq'],
+    instructions: `Propose dated Plan items for this Enquiry (a first response, a follow-up, a review).
+Prefer concrete actions over vague reminders.`,
+  }),
+  task({
+    id: 'enquiry.refresh_summary',
+    label: 'Refresh enquiry summary',
+    description: 'Rewrite summary from evidence.',
+    targetTypes: ['enquiry'],
+    placement: 'primary',
+    handbookSlugs: ['agent-faq'],
+    instructions: `Rewrite the Enquiry summary from source, stage, notes, and linked Company.`,
+  }),
+  task({
+    id: 'enquiry.draft_reply',
+    label: 'Draft reply',
+    description: 'First-response email in Voice.',
+    targetTypes: ['enquiry'],
+    placement: 'primary',
+    handbookSlugs: ['voice-and-tone', 'product', 'agent-faq'],
+    instructions: `Draft a first response to this Enquiry in Voice. Reference the Product handbook only where the
+Enquiry's summary or notes signal a match. Save the draft as a Note. Do not send.`,
+  }),
+  task({
+    id: 'enquiry.capture_decision',
+    label: 'Capture decision',
+    description: 'Log what was decided about this enquiry.',
+    targetTypes: ['enquiry'],
+    placement: 'overflow',
+    handbookSlugs: ['agent-faq'],
+    instructions: `Create a Decision linked to this Enquiry from recent commitments or the human's instruction.`,
+  }),
+  task({
+    id: 'enquiry.log_transcript',
+    label: 'Log transcript',
+    description: 'Parse call notes into CRM updates.',
+    targetTypes: ['enquiry'],
+    placement: 'overflow',
+    handbookSlugs: ['agent-faq'],
+    instructions: `The human will paste a call or chat transcript after this prompt.
+Append a Note, propose Plan items, update the summary only with clear evidence, extract Decisions.`,
+  }),
+
   // Opportunity
   task({
     id: 'opportunity.propose_plan',

package/src/modules/agent-tasks/resolve.ts

@@ -6,18 +6,19 @@ import type { PgColumn, PgTable } from 'drizzle-orm/pg-core'
 
 import type { Queryable } from '../../runtime/transaction.ts'
 import { companies } from '../companies/schema.ts'
-import { dealPeople, deals } from '../deals/schema.ts'
+import { deals } from '../deals/schema.ts'
 import { decisions } from '../decisions/schema.ts'
+import { enquiries } from '../enquiries/schema.ts'
 import { handbookPages } from '../handbook/schema.ts'
 import { candidates, roles } from '../hiring/schema.ts'
 import { notes } from '../notes/schema.ts'
 import { opportunities } from '../opportunities/schema.ts'
-import { partnershipPeople, partnerships } from '../partnerships/schema.ts'
-import { people } from '../people/schema.ts'
+import { partnerships } from '../partnerships/schema.ts'
+import { people, personLinks } from '../people/schema.ts'
 import { pipelineStages } from '../pipelines/schema.ts'
 import { planItems } from '../plans/schema.ts'
 import { positions } from '../positions/schema.ts'
-import { raisePeople, raises } from '../raises/schema.ts'
+import { raises } from '../raises/schema.ts'
 import { isRecordTargetType, resolveTargetNames, targetKey } from '../recordTargets.ts'
 import { workspaces } from '../workspace/schema.ts'
 import type { HandbookPageReference, PromptInputs, RelatedIdList, WorkspaceSignal } from './prompt.ts'
@@ -47,6 +48,7 @@ const DEEP_LINKS: Readonly<Partial<Record<AgentTaskTargetType, string>>> = {
   person: '/people',
   company: '/companies',
   deal: '/deals',
+  enquiry: '/enquiries',
   opportunity: '/opportunities',
   partnership: '/partnerships',
   raise: '/fundraising',
@@ -253,6 +255,33 @@ async function relatedFrom(
   return limitedIds(rows.map((row) => row.id))
 }
 
+/**
+ * The people on one pipeline record, capped and truncation-aware. Uses
+ * `person_links` directly rather than the shared helper because it needs the
+ * limit + 1 semantics of `relatedFrom`.
+ */
+async function personLinkIds(
+  db: Queryable,
+  workspaceId: string,
+  targetType: 'deal' | 'enquiry' | 'opportunity' | 'partnership' | 'raise',
+  targetId: string,
+): Promise<RelatedIdList> {
+  const rows = await db
+    .select({ id: personLinks.personId })
+    .from(personLinks)
+    .where(
+      and(
+        eq(personLinks.workspaceId, workspaceId),
+        eq(personLinks.targetType, targetType),
+        eq(personLinks.targetId, targetId),
+      ),
+    )
+    .orderBy(asc(personLinks.personId))
+    .limit(RELATED_ID_LIMIT + 1)
+
+  return limitedIds(rows.map((row) => row.id))
+}
+
 /**
  * The related record ids `agent-tasks.md`'s context recipe names, per target
  * type: positions for a person, people on a deal, the company behind a raise,
@@ -297,6 +326,12 @@ async function collectRelated(
           deals.id,
           workspaceScoped(deals.workspaceId, deals.companyId),
         ),
+        enquiry_ids: await relatedFrom(
+          db,
+          enquiries,
+          enquiries.id,
+          workspaceScoped(enquiries.workspaceId, enquiries.companyId),
+        ),
         opportunity_ids: await relatedFrom(
           db,
           opportunities,
@@ -326,14 +361,7 @@ async function collectRelated(
 
       return {
         company_ids: wholeList(deal === undefined ? [] : [deal.companyId]),
-        // The link table has no workspace column; the parent deal was already
-        // resolved inside this workspace, which is what scopes the join.
-        person_ids: await relatedFrom(
-          db,
-          dealPeople,
-          dealPeople.personId,
-          eq(dealPeople.dealId, targetId),
-        ),
+        person_ids: await personLinkIds(db, workspaceId, 'deal', targetId),
       }
     }
 
@@ -349,6 +377,21 @@ async function collectRelated(
             ? []
             : [opportunity.companyId],
         ),
+        person_ids: await personLinkIds(db, workspaceId, 'opportunity', targetId),
+      }
+    }
+
+    case 'enquiry': {
+      const [enquiry] = await db
+        .select({ companyId: enquiries.companyId })
+        .from(enquiries)
+        .where(and(eq(enquiries.workspaceId, workspaceId), eq(enquiries.id, targetId)))
+
+      return {
+        company_ids: wholeList(
+          enquiry?.companyId === null || enquiry === undefined ? [] : [enquiry.companyId],
+        ),
+        person_ids: await personLinkIds(db, workspaceId, 'enquiry', targetId),
       }
     }
 
@@ -360,12 +403,7 @@ async function collectRelated(
 
       return {
         company_ids: wholeList(partnership === undefined ? [] : [partnership.companyId]),
-        person_ids: await relatedFrom(
-          db,
-          partnershipPeople,
-          partnershipPeople.personId,
-          eq(partnershipPeople.partnershipId, targetId),
-        ),
+        person_ids: await personLinkIds(db, workspaceId, 'partnership', targetId),
       }
     }
 
@@ -377,12 +415,7 @@ async function collectRelated(
 
       return {
         company_ids: wholeList(raise === undefined ? [] : [raise.companyId]),
-        person_ids: await relatedFrom(
-          db,
-          raisePeople,
-          raisePeople.personId,
-          eq(raisePeople.raiseId, targetId),
-        ),
+        person_ids: await personLinkIds(db, workspaceId, 'raise', targetId),
       }
     }
 
@@ -433,6 +466,13 @@ const SWEEP_TABLES = {
     stageId: deals.stageId,
     summary: deals.summary,
   },
+  enquiry: {
+    table: enquiries,
+    id: enquiries.id,
+    workspaceId: enquiries.workspaceId,
+    stageId: enquiries.stageId,
+    summary: enquiries.summary,
+  },
   opportunity: {
     table: opportunities,
     id: opportunities.id,

package/src/modules/attachedRecords.ts

@@ -5,9 +5,11 @@ import { and, eq } from 'drizzle-orm'
 import type { Queryable } from '../runtime/transaction.ts'
 import * as activityRepository from './activities/repository.ts'
 import * as decisionRepository from './decisions/repository.ts'
+import { formAttachTargets } from './forms/schema.ts'
 import { candidates } from './hiring/schema.ts'
 import * as listRepository from './lists/repository.ts'
 import * as noteRepository from './notes/repository.ts'
+import * as personLinks from './personLinks.ts'
 import * as planRepository from './plans/repository.ts'
 
 /**
@@ -19,7 +21,12 @@ import * as planRepository from './plans/repository.ts'
  * record they described and reappear the day an id is reused.
  *
  * `plan_items` attach the same way but their check constraint allows only the
- * four pipeline types, so they are removed only for those targets.
+ * four pipeline types, so they are removed only for those targets. `person_links`
+ * follows the same rule: it holds a person's involvement in a pipeline record
+ * and its check constraint allows only the four pipeline types, so a deleted
+ * deal/opportunity/raise/partnership sheds its people here. `form_attach_targets`
+ * is the same shape: forms pinning submitters into a pre-existing pipeline
+ * record shed the mapping when the target goes.
  */
 
 /** Target types that can own attached records here. */
@@ -46,6 +53,26 @@ export async function deleteRecordsAttachedTo(
   const plans = PLAN_TARGET_TYPES.has(targetType)
     ? await planRepository.deleteForTarget(db, workspaceId, targetType, targetId)
     : 0
+  const links = PLAN_TARGET_TYPES.has(targetType)
+    ? await personLinks.deleteLinksForTarget(db, workspaceId, {
+        targetType: targetType as PipelineKind,
+        targetId,
+      })
+    : 0
+  const attachTargets = PLAN_TARGET_TYPES.has(targetType)
+    ? (
+        await db
+          .delete(formAttachTargets)
+          .where(
+            and(
+              eq(formAttachTargets.workspaceId, workspaceId),
+              eq(formAttachTargets.targetType, targetType),
+              eq(formAttachTargets.targetId, targetId),
+            ),
+          )
+          .returning({ formId: formAttachTargets.formId })
+      ).length
+    : 0
   const memberships = await listRepository.deleteMembershipsForTarget(
     db,
     workspaceId,
@@ -53,7 +80,7 @@ export async function deleteRecordsAttachedTo(
     targetId,
   )
 
-  return notes + activities + decisions + plans + memberships
+  return notes + activities + decisions + plans + links + attachTargets + memberships
 }
 
 /**

package/src/modules/companies/index.ts

@@ -1,5 +1,6 @@
 import type { KelpieModule } from '../../runtime/module.ts'
 import { createActivityRecorder } from '../activities/index.ts'
+import { createCustomFieldValues } from '../custom-fields/index.ts'
 import { companiesEvents } from './events.ts'
 import { mountCompaniesRoutes } from './routes.ts'
 import * as schema from './schema.ts'
@@ -15,7 +16,7 @@ import { registerCompaniesTools } from './tools.ts'
 export function createCompaniesModule(migrationsDirectory: string): KelpieModule {
   return {
     id: 'companies',
-    requires: ['workspace', 'activities'],
+    requires: ['workspace', 'activities', 'custom-fields'],
     structural: true,
     events: companiesEvents,
 
@@ -29,6 +30,7 @@ export function createCompaniesModule(migrationsDirectory: string): KelpieModule
           createId: context.createId,
           now: context.now,
         }),
+        customFields: createCustomFieldValues({ db: context.db }),
       })
 
       context.schema(schema, migrationsDirectory)

package/src/modules/companies/routes.ts

@@ -1,3 +1,4 @@
+import { customFieldsPatchShape } from '@kelpie/schemas'
 import type { Context, Hono } from 'hono'
 import { z } from 'zod'
 
@@ -5,6 +6,7 @@ import { pageBody, readIdFilter, readJsonBody, readListParameters } from '../../
 import type { Actor } from '../auth/actor.ts'
 import { resolveActorFrom } from '../auth/credentials.ts'
 import type { CredentialDependencies } from '../auth/credentials.ts'
+import { renderCustomFieldsForWire } from '../custom-fields/wire.ts'
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from './schema.ts'
 import type {
   CompaniesService,
@@ -31,6 +33,7 @@ const companyShape = {
   summary: z.string(),
   tags: z.array(z.string().min(1)),
   is_own: z.boolean(),
+  custom_fields: customFieldsPatchShape,
 }
 
 /**
@@ -53,6 +56,7 @@ export const createBody = z.strictObject({
   summary: companyShape.summary.default(''),
   tags: companyShape.tags.default([]),
   is_own: companyShape.is_own.default(false),
+  custom_fields: companyShape.custom_fields.default({}),
 })
 
 export const updateBody = z.strictObject(companyShape).partial()
@@ -77,6 +81,7 @@ export function toCreateInput(body: z.infer<typeof createBody>): CreateCompanyIn
     summary: body.summary,
     tags: body.tags,
     isOwn: body.is_own,
+    customFields: body.custom_fields,
   }
 }
 
@@ -96,6 +101,7 @@ export function toUpdateInput(body: z.infer<typeof updateBody>): UpdateCompanyIn
     ...(body.summary === undefined ? {} : { summary: body.summary }),
     ...(body.tags === undefined ? {} : { tags: body.tags }),
     ...(body.is_own === undefined ? {} : { isOwn: body.is_own }),
+    ...(body.custom_fields === undefined ? {} : { customFields: body.custom_fields }),
   }
 }
 
@@ -116,6 +122,7 @@ export function companyResponse(company: CompanyView): Record<string, unknown> {
     summary: company.summary,
     tags: company.tags,
     is_own: company.isOwn,
+    custom_fields: renderCustomFieldsForWire(company.customFields),
     created_at: company.createdAt.toISOString(),
     updated_at: company.updatedAt.toISOString(),
   }

package/src/modules/companies/schema.ts

@@ -1,5 +1,6 @@
 import { ACCOUNT_TYPES, COMPANY_STAGES, ICP_FITS, SIZE_BANDS } from '@kelpie/schemas'
-import { boolean, index, pgTable, text, unique } from 'drizzle-orm/pg-core'
+import type { CustomFieldValue } from '@kelpie/schemas'
+import { boolean, index, jsonb, pgTable, text, unique } from 'drizzle-orm/pg-core'
 
 import {
   checkOneOf,
@@ -46,6 +47,11 @@ export const companies = pgTable(
     // and subsidiary) so downstream views can distinguish self from prospects.
     // Loose semantics on purpose — zero or many rows may carry it.
     isOwn: boolean('is_own').notNull().default(false),
+    // Workspace-defined fields, keyed by definition key. See people/schema.ts.
+    customFields: jsonb('custom_fields')
+      .$type<Readonly<Record<string, CustomFieldValue>>>()
+      .notNull()
+      .default({}),
     createdAt: createdAt(),
     updatedAt: updatedAt(),
     searchVector: searchVector((): readonly SearchVectorPart[] => [