@crossworks/client-types 0.300.2 → 0.300.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crossworks/client-types",
-  "version": "0.300.2",
+  "version": "0.300.5",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/kinds.test.ts

@@ -0,0 +1,239 @@
+/**
+ * The kind registry (workspaces arch A1) and the lists of this package that
+ * derive from it. Each derived list is pinned to its value before the
+ * registry (v0.300.2): a change to who may share, search or see a kind is a
+ * reviewed edit of the pin below, never a side effect of a registry field.
+ *
+ * A list whose order is a contract (the tree's) is pinned in order; a list
+ * the code only asks membership of is pinned as a set (it is now in schema
+ * order). The parity with SQL (the enum, mantle_kind_class) is a db test:
+ * packages/db/src/kind-registry.db.test.ts.
+ */
+import { describe, expect, it } from 'vitest';
+import { ITEM_KINDS, ITEM_KIND_NAMES, kindClassOf, kindSpecOf, kindsWhere } from './kinds';
+import { TREE_KIND_SPECS, TREE_KINDS } from './tree';
+import { SEARCH_NODE_TYPES } from './search-query';
+import { CLIENT_ITEM_KINDS, MEMBER_ITEM_KINDS } from './member-kinds';
+
+const set = (xs: readonly string[]) => [...xs].sort();
+
+describe('the kind registry', () => {
+  it('names every node_type value once, in the schema order', () => {
+    // The enum (packages/db/src/schema/nodes.ts); the db test checks the
+    // live enum_range too.
+    expect(ITEM_KIND_NAMES).toEqual([
+      'branch',
+      'email',
+      'email_thread',
+      'file',
+      'note',
+      'sermon',
+      'contact',
+      'secret',
+      'task',
+      'event',
+      'printer_project',
+      'telegram_message',
+      'page',
+      'table',
+      'mantle_peer',
+      'documentation',
+      'journal',
+      'location',
+      'app',
+      'formula',
+      'draw',
+      'recall',
+    ]);
+  });
+
+  it('classes: the workspace kinds, one conversation kind, the rest Admin only', () => {
+    expect(set(kindsWhere((s) => s.class === 'workspace'))).toEqual(
+      set([
+        'branch',
+        'file',
+        'note',
+        'page',
+        'table',
+        'app',
+        'formula',
+        'draw',
+        'task',
+        'event',
+        'recall',
+      ]),
+    );
+    expect(kindsWhere((s) => s.class === 'conversation')).toEqual(['telegram_message']);
+    expect(kindClassOf('journal')).toBe('admin_only');
+    expect(kindClassOf('no-such-kind')).toBe('admin_only');
+    expect(kindSpecOf('no-such-kind')).toBeNull();
+    expect(kindSpecOf('toString')).toBeNull();
+  });
+
+  it('an Admin-only kind is never linked, shared with a contact or a folder share', () => {
+    for (const t of ITEM_KIND_NAMES) {
+      const s = ITEM_KINDS[t];
+      if (s.class !== 'admin_only') continue;
+      expect(s.publicLink, t).toBe(false);
+      expect(s.contactShare, t).toBe(false);
+      expect(s.tree?.shareable ?? false, t).toBe(false);
+      expect(s.library, t).toBe(false);
+    }
+  });
+
+  it('tree orders are unique and dense', () => {
+    const trees = ITEM_KIND_NAMES.flatMap((t) => {
+      const tree = ITEM_KINDS[t].tree as { order: number; liveOrder: number } | null;
+      return tree ? [tree] : [];
+    });
+    const n = trees.length;
+    expect(set(trees.map((t) => String(t.order)))).toEqual(set([...Array(n).keys()].map(String)));
+    expect(set(trees.map((t) => String(t.liveOrder)))).toEqual(
+      set([...Array(n).keys()].map(String)),
+    );
+  });
+
+  it('route prefixes are unique', () => {
+    const content = ITEM_KIND_NAMES.map((t) => ITEM_KINDS[t].route.content).filter(Boolean);
+    expect(new Set(content).size).toBe(content.length);
+    const v1 = ITEM_KIND_NAMES.map((t) => ITEM_KINDS[t].route.v1).filter(Boolean);
+    expect(new Set(v1).size).toBe(v1.length);
+  });
+});
+
+describe('derived lists, pinned to their value before the registry', () => {
+  it('TREE_KINDS keeps its order (a jackdaw contract)', () => {
+    expect(TREE_KINDS).toEqual([
+      'files',
+      'notes',
+      'pages',
+      'draw',
+      'tables',
+      'formulas',
+      'apps',
+      'tasks',
+      'events',
+      'contacts',
+      'secrets',
+      'recall',
+    ]);
+  });
+
+  it('TREE_KIND_SPECS: every spec as before, keyed in navigation order', () => {
+    expect(Object.keys(TREE_KIND_SPECS)).toEqual([...TREE_KINDS]);
+    expect(TREE_KIND_SPECS).toEqual({
+      files: {
+        kind: 'files',
+        root: 'files',
+        nodeType: 'file',
+        shareable: true,
+        sorts: ['name', 'updated'],
+      },
+      notes: {
+        kind: 'notes',
+        root: 'notes',
+        nodeType: 'note',
+        shareable: true,
+        sorts: ['updated', 'name'],
+      },
+      pages: {
+        kind: 'pages',
+        root: 'pages',
+        nodeType: 'page',
+        shareable: true,
+        sorts: ['updated', 'name'],
+      },
+      draw: {
+        kind: 'draw',
+        root: 'draw',
+        nodeType: 'draw',
+        shareable: true,
+        sorts: ['updated', 'name'],
+      },
+      tables: {
+        kind: 'tables',
+        root: 'tables',
+        nodeType: 'table',
+        shareable: true,
+        sorts: ['updated', 'name'],
+      },
+      formulas: {
+        kind: 'formulas',
+        root: 'formulas',
+        nodeType: 'formula',
+        shareable: true,
+        sorts: ['name', 'updated'],
+      },
+      apps: {
+        kind: 'apps',
+        root: 'apps',
+        nodeType: 'app',
+        shareable: true,
+        sorts: ['name', 'updated'],
+      },
+      tasks: {
+        kind: 'tasks',
+        root: 'tasks',
+        nodeType: 'task',
+        shareable: false,
+        sorts: ['due', 'updated', 'name'],
+      },
+      events: {
+        kind: 'events',
+        root: 'events',
+        nodeType: 'event',
+        shareable: false,
+        sorts: ['start', 'name'],
+      },
+      contacts: {
+        kind: 'contacts',
+        root: 'contacts',
+        nodeType: 'contact',
+        shareable: false,
+        sorts: ['name', 'updated'],
+      },
+      secrets: {
+        kind: 'secrets',
+        root: 'secrets',
+        nodeType: 'secret',
+        shareable: false,
+        sorts: ['name', 'updated'],
+      },
+      recall: {
+        kind: 'recall',
+        root: 'recall',
+        nodeType: 'recall',
+        shareable: false,
+        sorts: ['name', 'updated'],
+      },
+    });
+  });
+
+  it('SEARCH_NODE_TYPES (a set)', () => {
+    expect(set(SEARCH_NODE_TYPES)).toEqual(
+      set([
+        'branch',
+        'email',
+        'email_thread',
+        'file',
+        'note',
+        'page',
+        'sermon',
+        'contact',
+        'task',
+        'event',
+        'printer_project',
+        'telegram_message',
+        'documentation',
+        'journal',
+        'formula',
+        'draw',
+      ]),
+    );
+  });
+
+  it('MEMBER_ITEM_KINDS and CLIENT_ITEM_KINDS keep their order (deprecated, one pair release)', () => {
+    expect(MEMBER_ITEM_KINDS).toEqual(['page', 'note', 'draw', 'table', 'file']);
+    expect(CLIENT_ITEM_KINDS).toEqual(['page', 'note', 'file']);
+  });
+});

package/src/kinds.ts

@@ -0,0 +1,472 @@
+/**
+ * The kind registry (workspaces arch plan v2, section 9; A1): ONE entry per
+ * value of the `node_type` enum (packages/db/src/schema/nodes.ts). Every other
+ * TS kind list is derived from it, never copied:
+ *
+ *  - WORKSPACE_NODE_TYPES (@mantle/db), the class;
+ *  - TREE_KINDS and TREE_KIND_SPECS (./tree), TREE_LIVE_KINDS and
+ *    READER_TREE_KINDS (@mantle/content/tree), TREE_TOOL_KINDS
+ *    (@mantle/tools), the tree entry;
+ *  - SHAREABLE_TYPES and canShareNode, CONTACT_SHAREABLE_TYPES and
+ *    PEER_SHAREABLE_TYPES (@mantle/content), the share fields;
+ *  - SEARCH_NODE_TYPES (./search-query), searchable;
+ *  - TEAM_PRIVATE_CORPUS_TYPES and TEAM_NEVER_TYPES
+ *    (@mantle/content-core/profile-projections), teamHidden;
+ *  - MEMBER_ITEM_KINDS and CLIENT_ITEM_KINDS (./member-kinds), library: kept
+ *    one pair release, then they go with the field.
+ *
+ * Each field holds the value the code had when the registry came in (A1).
+ * Who may share or see a kind changes here only as a reviewed diff of the
+ * snapshot tests (kinds.test.ts and the tests next to each derived list),
+ * never as a side effect of another list.
+ *
+ * `class` must equal mantle_kind_class(t) in SQL (migration 0241); a db test
+ * checks it, and that the enum and these keys are the same set. The keys are
+ * in the order of the Drizzle enum (schema/nodes.ts); a list derived here
+ * keeps that order unless it says otherwise (the tree lists and the old
+ * Library lists keep their own).
+ *
+ * Pure and dependency free: the `@mantle/client-types/kinds` subpath, so
+ * jackdaw reads the same registry.
+ */
+import type { TreeSort } from './tree';
+
+/** 'workspace': granted to any workspace. 'conversation': belongs to the
+ *  workspace of the assistant that holds the chat. 'admin_only': lives in the
+ *  Admin workspace only. */
+export type KindClass = 'workspace' | 'conversation' | 'admin_only';
+
+/** A kind's place in the item tree. */
+export type KindTreeSpec = {
+  /** The tree kind (the URL segment, /api/tree/:kind). */
+  readonly kind: string;
+  /** The ltree root label of the kind (the `*_ROOT_LABEL` constants). */
+  readonly root: string;
+  /** Navigation order (TREE_KINDS). A jackdaw contract: never reorder. */
+  readonly order: number;
+  /** The order the brain lists the kinds it serves (TREE_LIVE_KINDS, the
+   *  shell's `treeKinds`, the tree tools' enum): apps joined after secrets. */
+  readonly liveOrder: number;
+  /** The item orders offered, the first being the default. */
+  readonly sorts: readonly TreeSort[];
+  /** Whether a folder of this kind may be shared below Admin. */
+  readonly shareable: boolean;
+};
+
+export type KindSpec = {
+  readonly class: KindClass;
+  readonly tree: KindTreeSpec | null;
+  /** May carry a public link (SHAREABLE_TYPES). 'files-folder': a folder,
+   *  only strictly under the `files` root (canShareNode). */
+  readonly publicLink: boolean | 'files-folder';
+  /** May be shared with one contact (CONTACT_SHAREABLE_TYPES). */
+  readonly contactShare: boolean;
+  /** May be granted to a linked brain by category (PEER_SHAREABLE_TYPES). */
+  readonly peerShare: boolean;
+  /** A `type` filter of GET /api/search (SEARCH_NODE_TYPES). */
+  readonly searchable: boolean;
+  /** The kind's item routes: the content prefix (`:id` follows it; the
+   *  member route lists are generated from it, route-scope.ts) and the
+   *  public API v1 prefix. Null where the kind has none. Nothing reads `v1`
+   *  yet: A4 generates the content rows of ROUTE_POLICY from both (plan v2,
+   *  section 7; D3, v1 answers as its base route). */
+  readonly route: { readonly content: string | null; readonly v1: string | null };
+  /** Hidden from a team surface: 'never' (opt-in or not), 'private-corpus'
+   *  (unless the owner opted in, teamPrivateReads), or not. */
+  readonly teamHidden: 'never' | 'private-corpus' | false;
+  /** The old Library lists: in MEMBER_ITEM_KINDS at `order`, and in
+   *  CLIENT_ITEM_KINDS too when `client`. Kept one pair release (A1), then
+   *  removed with them. */
+  readonly library: { readonly order: number; readonly client: boolean } | false;
+};
+
+const none = { content: null, v1: null } as const;
+
+export const ITEM_KINDS = {
+  branch: {
+    class: 'workspace',
+    tree: null,
+    publicLink: 'files-folder',
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: { content: '/api/files/folders', v1: null },
+    teamHidden: false,
+    library: false,
+  },
+  email: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: { content: '/api/email/messages', v1: null },
+    teamHidden: 'private-corpus',
+    library: false,
+  },
+  email_thread: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: none,
+    teamHidden: 'private-corpus',
+    library: false,
+  },
+  file: {
+    class: 'workspace',
+    tree: {
+      kind: 'files',
+      root: 'files',
+      order: 0,
+      liveOrder: 0,
+      sorts: ['name', 'updated'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/files/files', v1: '/api/v1/files' },
+    teamHidden: false,
+    library: { order: 4, client: true },
+  },
+  note: {
+    class: 'workspace',
+    tree: {
+      kind: 'notes',
+      root: 'notes',
+      order: 1,
+      liveOrder: 1,
+      sorts: ['updated', 'name'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/notes', v1: '/api/v1/notes' },
+    teamHidden: false,
+    library: { order: 1, client: true },
+  },
+  sermon: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: none,
+    teamHidden: false,
+    library: false,
+  },
+  contact: {
+    class: 'admin_only',
+    tree: {
+      kind: 'contacts',
+      root: 'contacts',
+      order: 9,
+      liveOrder: 8,
+      sorts: ['name', 'updated'],
+      shareable: false,
+    },
+    publicLink: false,
+    contactShare: false,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/contacts', v1: '/api/v1/contacts' },
+    teamHidden: false,
+    library: false,
+  },
+  secret: {
+    class: 'admin_only',
+    tree: {
+      kind: 'secrets',
+      root: 'secrets',
+      order: 10,
+      liveOrder: 9,
+      sorts: ['name', 'updated'],
+      shareable: false,
+    },
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: false,
+    route: { content: '/api/secrets', v1: null },
+    teamHidden: 'never',
+    library: false,
+  },
+  task: {
+    class: 'workspace',
+    tree: {
+      kind: 'tasks',
+      root: 'tasks',
+      order: 7,
+      liveOrder: 6,
+      sorts: ['due', 'updated', 'name'],
+      shareable: false,
+    },
+    publicLink: true,
+    contactShare: false,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/tasks', v1: '/api/v1/tasks' },
+    teamHidden: false,
+    library: false,
+  },
+  event: {
+    class: 'workspace',
+    tree: {
+      kind: 'events',
+      root: 'events',
+      order: 8,
+      liveOrder: 7,
+      sorts: ['start', 'name'],
+      shareable: false,
+    },
+    publicLink: true,
+    contactShare: false,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/events', v1: '/api/v1/events' },
+    teamHidden: false,
+    library: false,
+  },
+  printer_project: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: none,
+    teamHidden: false,
+    library: false,
+  },
+  telegram_message: {
+    class: 'conversation',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: none,
+    teamHidden: 'never',
+    library: false,
+  },
+  page: {
+    class: 'workspace',
+    tree: {
+      kind: 'pages',
+      root: 'pages',
+      order: 2,
+      liveOrder: 2,
+      sorts: ['updated', 'name'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/pages', v1: '/api/v1/pages' },
+    teamHidden: false,
+    library: { order: 0, client: true },
+  },
+  table: {
+    class: 'workspace',
+    tree: {
+      kind: 'tables',
+      root: 'tables',
+      order: 4,
+      liveOrder: 4,
+      sorts: ['updated', 'name'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: true,
+    searchable: false,
+    route: { content: '/api/tables', v1: '/api/v1/tables' },
+    teamHidden: false,
+    library: { order: 3, client: false },
+  },
+  mantle_peer: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: false,
+    route: none,
+    teamHidden: 'never',
+    library: false,
+  },
+  documentation: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: { content: '/api/docs/reader', v1: null },
+    teamHidden: false,
+    library: false,
+  },
+  journal: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: true,
+    route: { content: '/api/journal', v1: '/api/v1/journal' },
+    teamHidden: 'private-corpus',
+    library: false,
+  },
+  location: {
+    class: 'admin_only',
+    tree: null,
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: false,
+    route: none,
+    teamHidden: 'never',
+    library: false,
+  },
+  app: {
+    class: 'workspace',
+    tree: {
+      kind: 'apps',
+      root: 'apps',
+      order: 6,
+      liveOrder: 10,
+      sorts: ['name', 'updated'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: false,
+    searchable: false,
+    route: { content: '/api/apps', v1: null },
+    teamHidden: false,
+    library: false,
+  },
+  formula: {
+    class: 'workspace',
+    tree: {
+      kind: 'formulas',
+      root: 'formulas',
+      order: 5,
+      liveOrder: 5,
+      sorts: ['name', 'updated'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: false,
+    searchable: true,
+    route: { content: '/api/formulas', v1: null },
+    teamHidden: false,
+    library: false,
+  },
+  draw: {
+    class: 'workspace',
+    tree: {
+      kind: 'draw',
+      root: 'draw',
+      order: 3,
+      liveOrder: 3,
+      sorts: ['updated', 'name'],
+      shareable: true,
+    },
+    publicLink: true,
+    contactShare: true,
+    peerShare: true,
+    searchable: true,
+    route: { content: '/api/draws', v1: null },
+    teamHidden: false,
+    library: { order: 2, client: false },
+  },
+  recall: {
+    class: 'workspace',
+    // The tree lists maps only; a map's cards are recall_nodes rows, never
+    // nodes. Its folders are not shared below Admin yet (Recall R6).
+    tree: {
+      kind: 'recall',
+      root: 'recall',
+      order: 11,
+      liveOrder: 11,
+      sorts: ['name', 'updated'],
+      shareable: false,
+    },
+    publicLink: false,
+    contactShare: false,
+    peerShare: false,
+    searchable: false,
+    // A native map's id is its node's id (createRecallMap).
+    route: { content: '/api/recall/maps', v1: null },
+    teamHidden: false,
+    library: false,
+  },
+} as const satisfies Record<string, KindSpec>;
+
+type Kinds = typeof ITEM_KINDS;
+
+/** Every node type, as the registry names it (the `node_type` enum). */
+export type ItemKind = keyof Kinds;
+
+/** The registry keys, in the Drizzle enum's order. */
+export const ITEM_KIND_NAMES = Object.keys(ITEM_KINDS) as ItemKind[];
+
+/** The node types whose spec matches `P` (a type-level filter). */
+export type KindsWhere<P> = { [K in ItemKind]: Kinds[K] extends P ? K : never }[ItemKind];
+
+/** The node types whose spec passes `pick`, in registry order. Never empty for
+ *  the lists derived here (their snapshot tests say so). */
+export function kindsWhere<K extends ItemKind = ItemKind>(
+  pick: (spec: KindSpec, type: ItemKind) => boolean,
+): readonly [K, ...K[]] {
+  return ITEM_KIND_NAMES.filter((t) => pick(ITEM_KINDS[t], t)) as unknown as readonly [K, ...K[]];
+}
+
+/** The spec of `type`, or null for a value the registry does not know. */
+export function kindSpecOf(type: string): KindSpec | null {
+  return Object.prototype.hasOwnProperty.call(ITEM_KINDS, type)
+    ? ITEM_KINDS[type as ItemKind]
+    : null;
+}
+
+/** The class of `type` (mantle_kind_class in TS); an unknown value is
+ *  'admin_only', as the SQL's ELSE. */
+export function kindClassOf(type: string): KindClass {
+  return kindSpecOf(type)?.class ?? 'admin_only';
+}
+
+// ── Typed selections the derived lists use ──────────────────────────────────
+
+export type WorkspaceKind = KindsWhere<{ class: 'workspace' }>;
+export type PublicLinkKind = KindsWhere<{ publicLink: true | 'files-folder' }>;
+export type ContactShareKind = KindsWhere<{ contactShare: true }>;
+export type PeerShareKind = KindsWhere<{ peerShare: true }>;
+export type SearchableKind = KindsWhere<{ searchable: true }>;
+export type MemberLibraryKind = KindsWhere<{ library: { order: number } }>;
+export type ClientLibraryKind = KindsWhere<{ library: { client: true } }>;
+
+/** The tree kinds the registry names (`files`, `notes`, ...). */
+export type RegistryTreeKind = {
+  [K in ItemKind]: Kinds[K]['tree'] extends { kind: infer T } ? T : never;
+}[ItemKind];
+
+/** The node types with a tree entry, ordered by `key` of that entry. */
+export function treeKindsBy(key: 'order' | 'liveOrder'): readonly RegistryTreeKind[] {
+  return ITEM_KIND_NAMES.flatMap((t) => {
+    const tree: KindTreeSpec | null = ITEM_KINDS[t].tree;
+    return tree ? [tree] : [];
+  })
+    .sort((a, b) => a[key] - b[key])
+    .map((t) => t.kind as RegistryTreeKind);
+}

package/src/member-kinds.ts

@@ -3,8 +3,31 @@
  * what the Library lists. The ONE list, for the brain (member-space.ts,
  * member-library.ts) and the client alike (audit M2); a runtime constant, so
  * it is the `@mantle/client-types/member-kinds` subpath.
+ *
+ * DEPRECATED (workspaces arch A1): derived from the kind registry's `library`
+ * field (./kinds) and kept exported for one pair release, then removed. Use
+ * the registry.
  */
-export const MEMBER_ITEM_KINDS = ['page', 'note', 'draw', 'table', 'file'] as const;
+import {
+  ITEM_KINDS,
+  kindsWhere,
+  type ClientLibraryKind,
+  type ItemKind,
+  type MemberLibraryKind,
+} from './kinds';
+
+/** The registry's `library` kinds that pass `pick`, in the lists' own order. */
+function libraryKinds<K extends ItemKind>(pick: (client: boolean) => boolean): readonly K[] {
+  const order = (t: ItemKind) => {
+    const lib = ITEM_KINDS[t].library as { order: number } | false;
+    return lib ? lib.order : 0;
+  };
+  return kindsWhere<K>((s) => s.library !== false && pick(s.library.client))
+    .slice()
+    .sort((a, b) => order(a) - order(b));
+}
+
+export const MEMBER_ITEM_KINDS = libraryKinds<MemberLibraryKind>(() => true);
 export type MemberItemKind = (typeof MEMBER_ITEM_KINDS)[number];
 
 export function isMemberItemKind(v: unknown): v is MemberItemKind {
@@ -47,7 +70,7 @@ export function adminListStateOf(v: unknown): AdminListState {
 
 /** The kinds a CLIENT works with in their own space (client logins C5, plan
  *  section 6): pages and notes they write, files they upload. */
-export const CLIENT_ITEM_KINDS = ['page', 'note', 'file'] as const;
+export const CLIENT_ITEM_KINDS = libraryKinds<ClientLibraryKind>((client) => client);
 export type ClientItemKind = (typeof CLIENT_ITEM_KINDS)[number];
 
 export function isClientItemKind(v: unknown): v is ClientItemKind {

package/src/search-query.ts

@@ -3,26 +3,12 @@
  * the `search_nodes` / `search_chunks` MCP tools (mobile companion's search).
  * Pure so it can be unit-tested without the route runtime.
  */
+import { kindsWhere, type SearchableKind } from './kinds';
 
-/** Mirrors the `search_nodes` tool's `type` enum — the API's contract. */
-export const SEARCH_NODE_TYPES = [
-  'branch',
-  'email',
-  'email_thread',
-  'file',
-  'note',
-  'page',
-  'sermon',
-  'contact',
-  'task',
-  'event',
-  'printer_project',
-  'telegram_message',
-  'documentation',
-  'journal',
-  'formula',
-  'draw',
-] as const;
+/** The `type` filters of GET /api/search: the kind registry's `searchable`
+ *  (./kinds). Near the `search_nodes` tool's `type` enum, which also takes
+ *  `secret` (an Admin-only tool argument). */
+export const SEARCH_NODE_TYPES = kindsWhere<SearchableKind>((s) => s.searchable);
 
 export type SearchNodeType = (typeof SEARCH_NODE_TYPES)[number];
 

package/src/tree.ts

@@ -15,25 +15,19 @@ import type { AccessLevel } from './dto/access';
 import type { GrantWorkspaceRef, ListWorkspace } from './dto/grants';
 import type { TaskStatus } from './dto/rows';
 import type { AppTint } from './app-nav';
+import {
+  ITEM_KINDS,
+  ITEM_KIND_NAMES,
+  treeKindsBy,
+  type KindTreeSpec,
+  type RegistryTreeKind,
+} from './kinds';
 
-/** The kinds the tree serves, in navigation order. */
-export const TREE_KINDS = [
-  'files',
-  'notes',
-  'pages',
-  'draw',
-  'tables',
-  'formulas',
-  'apps',
-  'tasks',
-  'events',
-  'contacts',
-  'secrets',
-  // Recall v2's maps (its own content type, not pages). Appended last so no
-  // earlier kind's index moves. Served since the Recall screen (R3).
-  'recall',
-] as const;
-export type TreeKind = (typeof TREE_KINDS)[number];
+/** The kinds the tree serves, in navigation order: derived from the kind
+ *  registry (./kinds, each kind's `tree.order`). A jackdaw contract: the
+ *  order never changes (Recall, appended last, kept every earlier index). */
+export const TREE_KINDS = treeKindsBy('order') as readonly RegistryTreeKind[];
+export type TreeKind = RegistryTreeKind;
 
 export function isTreeKind(v: unknown): v is TreeKind {
   return typeof v === 'string' && (TREE_KINDS as readonly string[]).includes(v);
@@ -77,97 +71,25 @@ export type TreeKindSpec = {
   sorts: readonly TreeSort[];
 };
 
-export const TREE_KIND_SPECS: Readonly<Record<TreeKind, TreeKindSpec>> = {
-  files: {
-    kind: 'files',
-    root: 'files',
-    nodeType: 'file',
-    shareable: true,
-    sorts: ['name', 'updated'],
-  },
-  notes: {
-    kind: 'notes',
-    root: 'notes',
-    nodeType: 'note',
-    shareable: true,
-    sorts: ['updated', 'name'],
-  },
-  pages: {
-    kind: 'pages',
-    root: 'pages',
-    nodeType: 'page',
-    shareable: true,
-    sorts: ['updated', 'name'],
-  },
-  draw: {
-    kind: 'draw',
-    root: 'draw',
-    nodeType: 'draw',
-    shareable: true,
-    sorts: ['updated', 'name'],
-  },
-  tables: {
-    kind: 'tables',
-    root: 'tables',
-    nodeType: 'table',
-    shareable: true,
-    sorts: ['updated', 'name'],
-  },
-  formulas: {
-    kind: 'formulas',
-    root: 'formulas',
-    nodeType: 'formula',
-    shareable: true,
-    sorts: ['name', 'updated'],
-  },
-  apps: {
-    kind: 'apps',
-    root: 'apps',
-    nodeType: 'app',
-    shareable: true,
-    sorts: ['name', 'updated'],
-  },
-  tasks: {
-    kind: 'tasks',
-    root: 'tasks',
-    nodeType: 'task',
-    shareable: false,
-    sorts: ['due', 'updated', 'name'],
-  },
-  events: {
-    kind: 'events',
-    root: 'events',
-    nodeType: 'event',
-    shareable: false,
-    sorts: ['start', 'name'],
-  },
-  contacts: {
-    kind: 'contacts',
-    root: 'contacts',
-    nodeType: 'contact',
-    shareable: false,
-    sorts: ['name', 'updated'],
-  },
-  secrets: {
-    kind: 'secrets',
-    root: 'secrets',
-    nodeType: 'secret',
-    shareable: false,
-    sorts: ['name', 'updated'],
-  },
-  // The tree lists maps only; a map's cards are recall_nodes rows, never
-  // nodes, so they never appear as items.
-  // Not shareable YET: a map is granted beyond Admin only once Recall R6
-  // lets a workspace's assistant read maps. Until then the tree must not
-  // offer it.
-  recall: {
-    kind: 'recall',
-    root: 'recall',
-    nodeType: 'recall',
-    shareable: false,
-    sorts: ['name', 'updated'],
-  },
-};
+/** Derived from the kind registry (./kinds): one spec per tree kind, keyed
+ *  in navigation order. */
+export const TREE_KIND_SPECS: Readonly<Record<TreeKind, TreeKindSpec>> = Object.fromEntries(
+  ITEM_KIND_NAMES.flatMap((nodeType) => {
+    const tree: KindTreeSpec | null = ITEM_KINDS[nodeType].tree;
+    return tree ? [{ tree, nodeType }] : [];
+  })
+    .sort((a, b) => a.tree.order - b.tree.order)
+    .map(({ tree, nodeType }): [string, TreeKindSpec] => [
+      tree.kind,
+      {
+        kind: tree.kind as TreeKind,
+        root: tree.root,
+        nodeType,
+        shareable: tree.shareable,
+        sorts: tree.sorts,
+      },
+    ]),
+) as Record<TreeKind, TreeKindSpec>;
 
 /** One folder as the tree shows it. Counts are what THIS reader can see. */
 export type TreeFolder = {