@drakkar.software/octospaces-sdk 0.1.0 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakkar.software/octospaces-sdk",
-  "version": "0.1.0",
+  "version": "0.4.1",
   "description": "Shared headless spaces core — identity, registry, objects, and sync plumbing.",
   "type": "module",
   "sideEffects": false,

package/src/core/types.ts

@@ -1,11 +1,16 @@
 /**
- * Domain model for OctoSpaces — space + object types shared by the SDK and any UI.
+ * Domain model for OctoSpaces — space + generic object-tree types shared by the SDK.
  *
  * A space's contents are modelled as a tree of typed {@link ObjectNode}s stored in
- * a union-merged index at `spaces/{spaceId}/objects/_index`. Everything —  rooms,
- * categories, docs, projects, tasks — is an `ObjectNode` discriminated by `type`.
- * Apps extend the model by adding their own `ObjectType` strings; the generic
- * primitives here are app-neutral.
+ * a union-merged index at `spaces/{spaceId}/objects/_index`. The SDK is deliberately
+ * domain-agnostic: it defines only the generic {@link ObjectNode} envelope and the
+ * {@link ObjectType} string alias. Apps (OctoChat, OctoVault, …) declare their own
+ * type strings and descriptors — they are not defined here.
+ *
+ * Visibility and confidentiality are **per-node** properties, not per-space:
+ *   - {@link NodeAccess} controls who may reach a node's content.
+ *   - `enc` controls whether the node's content is E2EE under its own keyring.
+ * A space is a neutral container; its `_access` record holds only the owner + roster.
  */
 
 // Re-export SealedBlob so consumers get it from one place.
@@ -19,17 +24,15 @@ export type PresenceStatus = 'online' | 'away' | 'dnd' | 'offline';
 /** A security item's verification state. The theme maps each to a color (app-side). */
 export type VerificationLevel = 'verified' | 'pending' | 'unverified';
 
-/** Maps a joined private space's id → its owner-issued member cap-cert (serialized
- *  JSON). Persisted both in device-local kv (`member-caps.ts`) and, for durability,
- *  in the user's own synced `_spaces` doc so a fresh device re-hydrates it. */
+/** Maps a joined space's id → its owner-issued member cap-cert (serialized JSON).
+ *  Persisted both in device-local kv and, for durability, in the user's own synced
+ *  `_spaces` doc so a fresh device re-hydrates it. */
 export type CapMap = Record<string, string>;
 
-/** Maps a joined PUBLIC space's id → its invitation credential (the owner-signed cap
- *  plus the link's ephemeral private key) SEALED to the account's own key. Unlike a
- *  member cap (safe in the clear — see {@link CapMap}), a public-join credential
- *  embeds a bearer secret, so it is sealed before riding in the plaintext `_spaces`
- *  doc. Recovered on any device with the same seed. See `account-seal.ts` and
- *  `space-access-store.ts`. */
+/** Maps a joined link-access key → its sealed invitation credential (cap + ephemeral
+ *  private key) SEALED to the account's own key. Keys are either `spaceId` (space-level
+ *  link) or `${spaceId}:${nodeId}` (per-node invite link). Sealed because it embeds a
+ *  bearer secret; recovered on any device with the same seed. */
 export type PubAccessMap = Record<string, import('../sync/account-seal.js').SealedBlob>;
 
 /** Maps a DM peer's userId → the private DM-space id shared with them. */
@@ -55,9 +58,8 @@ export interface ReadPrefs {
   rooms: Record<string, ReadValue>;
 }
 
-/** Whether a space encrypts its content client-side. */
-export type SpaceVisibility = 'private' | 'public';
-
+/** A joined or listed space. Visibility and encryption are per-node (see ObjectNode),
+ *  not per-space — a space is a neutral container. */
 export interface Space {
   id: ID;
   name: string;
@@ -67,96 +69,60 @@ export interface Space {
   image?: string;
   members: number;
   unread?: number;
-  /** 'private' (E2EE keyring, the default) or 'public' (plaintext, joined via a
-   *  space-wide invitation link). Absent ⇒ treat as 'private' (back-compat). */
-  visibility?: SpaceVisibility;
-  /** Public spaces only: the owner's userId (derived from the cap issuer). */
-  ownerId?: string;
-  /** Public spaces only (joiner side): whether this identity's invite link grants write. */
-  write?: boolean;
-}
-
-/** Legacy room kind — used while apps migrate their content onto objects.
- *  New code should use {@link RoomSubtype} directly. */
-export type RoomKind = 'channel' | 'dm' | 'automated';
-
-/** Scheduled-fetch cadence for automated rooms. */
-export type AutomationSchedule =
-  | { kind: 'interval'; everyMin: number }
-  | { kind: 'daily'; hour: number; minute: number }
-  | { kind: 'weekly'; weekday: number; hour: number; minute: number }
-  | { kind: 'cron'; expression: string };
-
-/** Stored, synced configuration of an `automated` room. */
-export interface AutomationMeta {
-  providerId: string;
-  params: Record<string, unknown>;
-  intervalMin: number;
-  schedule?: AutomationSchedule;
-  onOpen?: boolean;
-  enabled: boolean;
-  credential: import('../sync/account-seal.js').SealedBlob;
-  botUserId?: string;
-  runOnDeviceId: string | null;
-  lastRunAt: number | null;
-  lastFetchHash?: string | null;
-  lastError: string | null;
-}
-
-/** A transitional Room shape (used while apps migrate onto the object model). */
-export interface Room {
-  id: ID;
-  spaceId: ID;
-  category: string;
-  name: string;
-  kind: RoomKind;
-  topic?: string;
-  unread?: number;
-  mention?: boolean;
-  avatar?: string;
-  automation?: AutomationMeta;
 }
 
 // ── Object model ─────────────────────────────────────────────────────────────
-// Everything in a space — rooms, categories, docs, projects, etc. — is an
-// ObjectNode with a type. Apps extend ObjectType with their own strings.
+// Everything in a space is an ObjectNode with a type string. Apps (OctoChat,
+// OctoVault, …) define their own type strings; none are baked into the SDK.
 
-/** The builtin object types. Custom types ride the same `string` field. */
-export type BuiltinObjectType = 'room' | 'category' | 'automation' | 'doc' | 'project' | 'task';
-export type ObjectType = BuiltinObjectType | (string & {});
+/** Any string an app assigns as an object's type. No builtins are defined here —
+ *  each app declares its own type strings in its local SDK. */
+export type ObjectType = string;
 
-/** Runtime set of builtin type strings for renderer branching. */
-export const BUILTIN_OBJECT_TYPES: readonly BuiltinObjectType[] = ['room', 'category', 'automation', 'doc', 'project', 'task'];
-
-/** How an object's content syncs. Builtins infer this; custom types set it explicitly. */
+/** How an object's content syncs. Apps may set this per-type explicitly. */
 export type ObjectContentKind = 'merge' | 'append' | 'none';
 
-/** When `type === 'room'`, the room flavour. */
-export type RoomSubtype = 'channel' | 'dm' | 'automation';
+/** Who may read a node's content (independent from whether it is E2EE):
+ *  - `'public'`  — world-readable; anonymous users may access the content. The node
+ *                  is listed in the global object directory (`_index/objects/{shard}`).
+ *  - `'space'`   — any member of the parent space. The default for new nodes.
+ *  - `'invite'`  — only members explicitly invited to this node (via its own per-node
+ *                  keyring for E2EE nodes, or via a per-node cap for plaintext nodes).
+ *                  Non-invited space members see a placeholder row (no title/emoji). */
+export type NodeAccess = 'public' | 'space' | 'invite';
 
 /**
  * One entry in a space's object index (`spaces/{spaceId}/objects/_index`).
  * Identity + tree position + light metadata ONLY — heavy content (messages, doc
- * blocks, project event log) lives in a per-object content doc keyed by `id`.
+ * blocks, event logs) lives in per-object content docs keyed by `id`.
+ *
+ * The index doc is always **plaintext** (member-gated). For `invite` nodes the
+ * `title` and `emoji` fields are stored empty in the index — only invited members
+ * can recover the real title from the node's content doc or encrypted keyring entry.
  */
 export interface ObjectNode {
   id: ID;
   type: ObjectType;
-  subtype?: RoomSubtype;
   parentId: ID | null;
   order: number;
   title: string;
   emoji?: string;
   updatedAt: number;
   archived?: boolean;
-  automation?: AutomationMeta;
   contentKind?: ObjectContentKind;
+  /** Who may access this node's content. Absent ⇒ `'space'`. */
+  access?: NodeAccess;
+  /** True ⇒ this node's content is E2EE under the SPACE-WIDE keyring at
+   *  `spaces/{spaceId}/_keyring`. All `enc` nodes in a space share one CEK.
+   *  The combination `public + enc` is invalid. */
+  enc?: boolean;
+  /** App-specific fields. Apps store type-specific metadata here. */
   meta?: Record<string, unknown>;
 }
 
-/** The object-index doc: the union-merged list of every object in a space. */
+/** The object-index doc stored at `spaces/{spaceId}/objects/_index`. */
 export interface ObjectsIndex {
-  v: 1;
+  v: 1 | 2;
   objects: ObjectNode[];
   updatedAt: number;
 }

package/src/index.ts

@@ -11,23 +11,18 @@ export type { KvAdapter } from './core/adapters.js';
 // Domain types
 export type {
   ID,
+  NodeAccess,
   ObjectNode,
   ObjectType,
   ObjectsIndex,
   ObjectContentKind,
-  RoomSubtype,
-  AutomationMeta,
-  Room,
-  RoomKind,
   Space,
-  SpaceVisibility,
   CapMap,
   PubAccessMap,
   DmMap,
   MutePrefs,
   ReadPrefs,
   ArchivedDms,
-  BUILTIN_OBJECT_TYPES,
 } from './core/types.js';
 
 // Ids
@@ -38,6 +33,7 @@ export {
   OBJECT_COLLECTIONS,
   ownerScope,
   spaceMemberScope,
+  nodeMemberScope,
   accountScope,
   linkedDeviceScope,
   keyringName,
@@ -45,10 +41,18 @@ export {
   keyringPush,
   objIndexPull,
   objIndexPush,
+  objPubName,
+  objPubPull,
+  objPubPush,
+  objInvName,
+  objInvPull,
+  objInvPush,
+  objectDirName,
+  objectDirPull,
   spacesPull,
   spacesPush,
-  roomsRegistryPull,
-  roomsRegistryPush,
+  spaceAccessPull,
+  spaceAccessPush,
   profilePull,
   profilePush,
   objLogPull,
@@ -61,7 +65,6 @@ export {
   typesIndexPush,
   attachmentPull,
   attachmentPush,
-  spaceIndexPull,
   userIdFromEdPub,
   bytesToHex,
 } from './sync/paths.js';
@@ -112,9 +115,15 @@ export type {
 export { sealToSelf, unsealFromSelf, sealToRecipient, unsealFromRecipient } from './sync/account-seal.js';
 export type { SealedBlob } from './sync/account-seal.js';
 
-// Space access (replaces SpaceEncryptor)
-export { SpaceAccessError, getSpaceAccess, buildSpaceAccess, clearSpaceAccessCache } from './sync/space-access.js';
-export type { SpaceAccessHandle } from './sync/space-access.js';
+// Node access (per-node encryptor + client resolver, replaces per-space access)
+export {
+  SpaceAccessError,
+  getSpaceClient,
+  getNodeAccess,
+  buildNodeAccess,
+  clearNodeAccessCache,
+} from './sync/space-access.js';
+export type { NodeAccessHandle } from './sync/space-access.js';
 
 // Space access store (replaces member-caps + pubspace-caps)
 export {
@@ -122,6 +131,9 @@ export {
   getSpaceAccessEntry,
   saveSpaceAccessEntry,
   removeSpaceAccessEntry,
+  getNodeAccessEntry,
+  saveNodeAccessEntry,
+  removeNodeAccessEntry,
   localSpaceAccessEntries,
   memberCapsFromStore,
   linkAccessFromStore,
@@ -131,7 +143,6 @@ export type { SpaceAccessEntry, SpaceAccessMap } from './sync/space-access-store
 
 // Registry
 export {
-  DEFAULT_CATEGORY,
   readSpaces,
   updateSpacesDoc,
   updateMutesDoc,
@@ -142,19 +153,17 @@ export {
   setDmMapping,
   writeSpaces,
   reorderSpaces,
-  readRooms,
-  writeRooms,
+  readSpaceAccess,
+  writeSpaceAccess,
   addSpaceMember,
   removeSpaceMember,
   addJoinedSpace,
   addJoinedSpaceWithCap,
   addJoinedSpaceWithLinkAccess,
   createSpace,
-  normalizeCategories,
   reconcileSpaceMeta,
   onSpaceMeta,
   broadcastSpaceMeta,
-  CategoryError,
 } from './spaces/registry.js';
 export type { SpaceMeta, SpaceMetaUpdate } from './spaces/registry.js';
 
@@ -163,18 +172,30 @@ export {
   makeJoinRequest,
   inviteToSpace,
   acceptSpaceInvite,
-  addDeviceToSpaceKeyring,
   encodeSpaceInviteLink,
   decodeSpaceInviteLink,
   createSpaceInviteLink,
   joinSpaceByLink,
   recoverSpaceAccess,
+  addDeviceToSpaceKeyring,
 } from './spaces/members.js';
 export type { JoinRequest, SpaceInviteLinkToken } from './spaces/members.js';
 
+// Nodes (per-node creation + access management + invite flows)
+export {
+  createNode,
+  setNodeAccess,
+  inviteToNode,
+  acceptNodeInvite,
+  createNodeInviteLink,
+  decodeNodeInviteLink,
+  encodeNodeInviteLink,
+  joinNodeByLink,
+} from './spaces/nodes.js';
+export type { CreateNodeInput, NodeInviteBundle, NodeInviteLinkToken } from './spaces/nodes.js';
+
 // Object core
 export {
-  categoryId,
   buildTree,
   breadcrumbs,
   ancestors,
@@ -185,22 +206,15 @@ export {
   reparentObject,
   reorderObjects,
   archiveObject,
-  seedIndexNodes,
-  objectsToRoomCategories,
-  excludeAutomatedRooms,
-  roomKindToSubtype,
-  subtypeToRoomKind,
 } from './objects/objects.js';
-export type { ObjectTreeNode, NewObjectInput, AdaptedCategory, SeedRoom } from './objects/objects.js';
+export type { ObjectTreeNode, NewObjectInput } from './objects/objects.js';
 
 // Object index
 export {
-  readIndexRooms,
-  readSpaceIndexRooms,
-  readSpaceRooms,
   pushIndexSeed,
   seedSpaceObjectIndex,
   updateObjectIndex,
+  readObjectTree,
 } from './spaces/object-index.js';
 
 // Pairing

package/src/objects/objects.test.ts

@@ -6,18 +6,11 @@ import {
   breadcrumbs,
   buildTree,
   ancestors,
-  categoryId,
-  DEFAULT_CATEGORY,
   nextOrder,
   patchObject,
   reparentObject,
   reorderObjects,
-  seedIndexNodes,
   subtreeIds,
-  objectsToRoomCategories,
-  excludeAutomatedRooms,
-  roomKindToSubtype,
-  subtypeToRoomKind,
 } from './objects.js';
 
 const NOW = 1_700_000_000_000;
@@ -25,7 +18,7 @@ const NOW = 1_700_000_000_000;
 function makeNode(overrides: Partial<ObjectNode> = {}): ObjectNode {
   return {
     id: 'n1',
-    type: 'room',
+    type: 'item',
     parentId: null,
     order: 1,
     title: 'Test',
@@ -34,22 +27,6 @@ function makeNode(overrides: Partial<ObjectNode> = {}): ObjectNode {
   };
 }
 
-describe('DEFAULT_CATEGORY', () => {
-  it('is CHANNELS', () => { expect(DEFAULT_CATEGORY).toBe('CHANNELS'); });
-});
-
-describe('categoryId', () => {
-  it('is deterministic for the same name', () => {
-    expect(categoryId('Channels')).toBe(categoryId('Channels'));
-  });
-  it('differs for different names', () => {
-    expect(categoryId('Alpha')).not.toBe(categoryId('Beta'));
-  });
-  it('starts with cat-', () => {
-    expect(categoryId('test')).toMatch(/^cat-/);
-  });
-});
-
 describe('nextOrder', () => {
   it('returns 1 for empty sibling list', () => {
     expect(nextOrder([])).toBe(1);
@@ -74,13 +51,13 @@ describe('buildTree', () => {
 
   it('nests children under their parent', () => {
     const nodes: ObjectNode[] = [
-      makeNode({ id: 'cat', type: 'category', parentId: null, order: 1 }),
-      makeNode({ id: 'room', type: 'room', parentId: 'cat', order: 1 }),
+      makeNode({ id: 'folder', type: 'folder', parentId: null, order: 1 }),
+      makeNode({ id: 'page', type: 'page', parentId: 'folder', order: 1 }),
     ];
     const tree = buildTree(nodes);
     expect(tree).toHaveLength(1);
     expect(tree[0].children).toHaveLength(1);
-    expect(tree[0].children[0].id).toBe('room');
+    expect(tree[0].children[0].id).toBe('page');
   });
 
   it('excludes archived nodes by default', () => {
@@ -147,17 +124,22 @@ describe('subtreeIds', () => {
 
 describe('addObject', () => {
   it('appends a new node with correct order', () => {
-    const { nodes, node } = addObject([], { type: 'room', title: 'general' }, NOW);
+    const { nodes, node } = addObject([], { type: 'page', title: 'Intro' }, NOW);
     expect(nodes).toHaveLength(1);
-    expect(node.title).toBe('general');
-    expect(node.type).toBe('room');
+    expect(node.title).toBe('Intro');
+    expect(node.type).toBe('page');
     expect(node.order).toBe(1);
   });
 
   it('respects provided id', () => {
-    const { node } = addObject([], { id: 'my-id', type: 'category', title: 'Channels' }, NOW);
+    const { node } = addObject([], { id: 'my-id', type: 'folder', title: 'Docs' }, NOW);
     expect(node.id).toBe('my-id');
   });
+
+  it('passes meta through to the node', () => {
+    const { node } = addObject([], { type: 'task', title: 'Fix bug', meta: { priority: 'high' } }, NOW);
+    expect(node.meta).toEqual({ priority: 'high' });
+  });
 });
 
 describe('patchObject', () => {
@@ -172,19 +154,19 @@ describe('patchObject', () => {
 describe('reparentObject', () => {
   it('moves a node to a new parent', () => {
     const nodes: ObjectNode[] = [
-      makeNode({ id: 'cat-a', type: 'category', parentId: null }),
-      makeNode({ id: 'cat-b', type: 'category', parentId: null }),
-      makeNode({ id: 'room', type: 'room', parentId: 'cat-a' }),
+      makeNode({ id: 'folder-a', type: 'folder', parentId: null }),
+      makeNode({ id: 'folder-b', type: 'folder', parentId: null }),
+      makeNode({ id: 'page', type: 'page', parentId: 'folder-a' }),
     ];
-    const result = reparentObject(nodes, 'room', 'cat-b', NOW);
-    const room = result.find(n => n.id === 'room')!;
-    expect(room.parentId).toBe('cat-b');
+    const result = reparentObject(nodes, 'page', 'folder-b', NOW);
+    const page = result.find(n => n.id === 'page')!;
+    expect(page.parentId).toBe('folder-b');
   });
 
   it('rejects making a node its own descendant', () => {
     const nodes: ObjectNode[] = [
-      makeNode({ id: 'parent', type: 'category', parentId: null }),
-      makeNode({ id: 'child', type: 'room', parentId: 'parent' }),
+      makeNode({ id: 'parent', type: 'folder', parentId: null }),
+      makeNode({ id: 'child', type: 'page', parentId: 'parent' }),
     ];
     const result = reparentObject(nodes, 'parent', 'child', NOW);
     expect(result).toBe(nodes); // unchanged
@@ -214,75 +196,53 @@ describe('archiveObject', () => {
   });
 });
 
-describe('seedIndexNodes', () => {
-  it('creates category + room nodes', () => {
-    const nodes = seedIndexNodes([{ id: 'r1', name: 'general', kind: 'channel', category: 'CHANNELS' }], NOW);
-    expect(nodes.some(n => n.type === 'category')).toBe(true);
-    expect(nodes.some(n => n.type === 'room')).toBe(true);
-  });
+// ── access / enc fields ───────────────────────────────────────────────────────
 
-  it('dedupes categories', () => {
-    const rooms = [
-      { id: 'r1', name: 'general', kind: 'channel' as const, category: 'CHANNELS' },
-      { id: 'r2', name: 'random', kind: 'channel' as const, category: 'CHANNELS' },
-    ];
-    const nodes = seedIndexNodes(rooms, NOW);
-    const cats = nodes.filter(n => n.type === 'category');
-    expect(cats).toHaveLength(1);
+describe('addObject — access / enc', () => {
+  it('omits access field when not provided (defaults to space)', () => {
+    const { node } = addObject([], { type: 'page', title: 'Space' }, NOW);
+    expect(node).not.toHaveProperty('access');
   });
-});
 
-describe('roomKindToSubtype / subtypeToRoomKind', () => {
-  it('channel ↔ channel', () => {
-    expect(roomKindToSubtype('channel')).toBe('channel');
-    expect(subtypeToRoomKind('channel')).toBe('channel');
+  it('omits access field when access is "space"', () => {
+    const { node } = addObject([], { type: 'page', title: 'Space', access: 'space' }, NOW);
+    expect(node).not.toHaveProperty('access');
   });
-  it('dm ↔ dm', () => {
-    expect(roomKindToSubtype('dm')).toBe('dm');
-    expect(subtypeToRoomKind('dm')).toBe('dm');
+
+  it('sets access:"public" on the node', () => {
+    const { node } = addObject([], { type: 'page', title: 'Public', access: 'public' }, NOW);
+    expect(node.access).toBe('public');
   });
-  it('automated ↔ automation', () => {
-    expect(roomKindToSubtype('automated')).toBe('automation');
-    expect(subtypeToRoomKind('automation')).toBe('automated');
+
+  it('sets access:"invite" on the node', () => {
+    const { node } = addObject([], { type: 'page', title: 'Private', access: 'invite' }, NOW);
+    expect(node.access).toBe('invite');
   });
-});
 
-describe('objectsToRoomCategories', () => {
-  it('returns null for empty index', () => {
-    expect(objectsToRoomCategories([], 'sp-1', 'CHANNELS')).toBeNull();
+  it('omits enc field when not provided or false', () => {
+    const { node: n1 } = addObject([], { type: 'page', title: 'T' }, NOW);
+    const { node: n2 } = addObject([], { type: 'page', title: 'T', enc: false }, NOW);
+    expect(n1).not.toHaveProperty('enc');
+    expect(n2).not.toHaveProperty('enc');
   });
 
-  it('groups rooms under their category', () => {
-    const nodes: ObjectNode[] = [
-      makeNode({ id: 'cat', type: 'category', parentId: null, order: 1, title: 'CHANNELS' }),
-      makeNode({ id: 'room', type: 'room', parentId: 'cat', order: 1, title: 'general' }),
-    ];
-    const cats = objectsToRoomCategories(nodes, 'sp-1', 'CHANNELS')!;
-    expect(cats).toHaveLength(1);
-    expect(cats[0].name).toBe('CHANNELS');
-    expect(cats[0].rooms[0].name).toBe('general');
+  it('sets enc:true on the node', () => {
+    const { node } = addObject([], { type: 'page', title: 'E2EE', enc: true }, NOW);
+    expect(node.enc).toBe(true);
   });
 });
 
-describe('excludeAutomatedRooms', () => {
-  it('removes categories that held ONLY automated rooms', () => {
-    const cats = [{ name: 'C', rooms: [{ id: 'r', spaceId: 's', category: 'C', name: 'bot', kind: 'automated' as const }] }];
-    const result = excludeAutomatedRooms(cats);
-    // A category whose ONLY room was automated gets dropped entirely.
-    expect(result).toHaveLength(0);
+describe('patchObject — access / enc', () => {
+  it('patches access field', () => {
+    const nodes = [makeNode({ id: 'x', title: 'X' })];
+    const patched = patchObject(nodes, 'x', { access: 'public' }, NOW);
+    expect(patched[0].access).toBe('public');
   });
 
-  it('keeps categories that still have non-automated rooms', () => {
-    const cats = [{
-      name: 'C',
-      rooms: [
-        { id: 'r1', spaceId: 's', category: 'C', name: 'bot', kind: 'automated' as const },
-        { id: 'r2', spaceId: 's', category: 'C', name: 'general', kind: 'channel' as const },
-      ],
-    }];
-    const result = excludeAutomatedRooms(cats);
-    expect(result).toHaveLength(1);
-    expect(result[0].rooms).toHaveLength(1);
-    expect(result[0].rooms[0].name).toBe('general');
+  it('patches enc field', () => {
+    const nodes = [makeNode({ id: 'x', title: 'X' })];
+    const patched = patchObject(nodes, 'x', { enc: true }, NOW);
+    expect(patched[0].enc).toBe(true);
   });
 });
+