@xcitedbs/client 0.2.10 → 0.2.11

package/dist/client.d.ts

@@ -1,4 +1,4 @@
-import { AccessCheckResult, AppAuthConfig, AppEmailConfig, AppEmailTemplates, AppUser, AppUserTokenPair, EmailTestResponse, ForgotPasswordResponse, SendVerificationResponse, BranchInfo, CommitRecord, DatabaseContext, DiffRef, DiffResult, Flags, ListIdentifierChildrenResult, ListIdentifiersResult, LockInfo, LogEntry, MergeResult, MetaValue, PlatformRegisterResult, PolicySubjectInput, UnqueryResult, UnqueryTemplate, PolicyUpdateResponse, RealtimeEvent, SecurityConfig, SecurityPolicy, StoredTriggerResponse, TriggerDefinition, StoredPolicyResponse, SubscriptionOptions, TagRecord, TextSearchQuery, TextSearchResult, ProjectSearchSettings, ProjectSearchSettingsUpdate, VectorIndexEstimate, RagQueryOptions, RagQueryResult, RagStreamEvent, OAuthProvidersResponse, ProjectInfo, PlatformRegistrationConfig, PlatformWorkspacesResponse, TokenPair, UserInfo, ApiKeyInfo, WriteDocumentOptions, CreateTestSessionOptions, XCiteDBClientOptions, XCiteDBJwtClaims, XCiteQuery, UserIsolationConfig } from './types';
+import { AccessCheckResult, AppAuthConfig, AppEmailConfig, AppEmailTemplates, AppUser, AppUserTokenPair, EmailTestResponse, ForgotPasswordResponse, SendVerificationResponse, BranchInfo, BookmarkRecord, CheckpointRecord, CommitRecord, CompareRef, CompareResult, DatabaseContext, DiffRef, DiffResult, Flags, ListIdentifierChildrenResult, ListIdentifiersResult, LockInfo, LogEntry, MergeResult, PublishResult, WorkspaceInfo, MetaValue, PlatformRegisterResult, PolicySubjectInput, UnqueryResult, UnqueryTemplate, PolicyUpdateResponse, RealtimeEvent, SecurityConfig, SecurityPolicy, StoredTriggerResponse, TriggerDefinition, StoredPolicyResponse, SubscriptionOptions, TagRecord, TextSearchQuery, TextSearchResult, ProjectSearchSettings, ProjectSearchSettingsUpdate, VectorIndexEstimate, RagQueryOptions, RagQueryResult, RagStreamEvent, OAuthProvidersResponse, ProjectInfo, PlatformRegistrationConfig, PlatformWorkspacesResponse, TokenPair, UserInfo, ApiKeyInfo, WriteDocumentOptions, CreateTestSessionOptions, XCiteDBClientOptions, XCiteDBJwtClaims, XCiteQuery, UserIsolationConfig } from './types';
 import { WebSocketSubscription } from './websocket';
 export declare class XCiteDBClient {
     private baseUrl;
@@ -293,12 +293,34 @@ export declare class XCiteDBClient {
      * the server (namespace + shared paths). Does not send `X-Prefix`; identifiers in requests are rewritten.
      */
     enableUserIsolation(): Promise<UserIsolationConfig>;
+    createWorkspace(name: string, fromBranch?: string, fromDate?: string): Promise<void>;
+    /** @deprecated Use {@link createWorkspace}. */
     createBranch(name: string, fromBranch?: string, fromDate?: string): Promise<void>;
+    deleteWorkspace(name: string): Promise<void>;
+    /** @deprecated Use {@link deleteWorkspace}. */
     deleteBranch(name: string): Promise<void>;
+    deleteWorkspaceRevision(workspace: string, date: string): Promise<void>;
+    /** @deprecated Use {@link deleteWorkspaceRevision}. */
     deleteRevision(branch: string, date: string): Promise<void>;
+    listWorkspaces(): Promise<WorkspaceInfo[]>;
+    /** @deprecated Use {@link listWorkspaces}. */
     listBranches(): Promise<BranchInfo[]>;
+    getWorkspace(name: string): Promise<WorkspaceInfo>;
+    /** @deprecated Use {@link getWorkspace}. */
     getBranch(name: string): Promise<BranchInfo>;
+    createCheckpoint(message: string, author?: string): Promise<CheckpointRecord>;
+    /** @deprecated Use {@link createCheckpoint}. */
     createCommit(message: string, author?: string): Promise<CommitRecord>;
+    listCheckpoints(options?: {
+        branch?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        checkpoints: CheckpointRecord[];
+        total: number;
+        branch: string;
+    }>;
+    /** @deprecated Use {@link listCheckpoints}. */
     listCommits(options?: {
         branch?: string;
         limit?: number;
@@ -308,13 +330,33 @@ export declare class XCiteDBClient {
         total: number;
         branch: string;
     }>;
+    getCheckpoint(checkpointId: string): Promise<CheckpointRecord>;
+    /** @deprecated Use {@link getCheckpoint}. */
     getCommit(commitId: string): Promise<CommitRecord>;
+    revertToCheckpoint(checkpointId: string, _confirm?: boolean): Promise<{
+        rolled_back_checkpoints: string[];
+        rolled_back_commits?: string[];
+        current_tip: string;
+    }>;
+    /** @deprecated Use {@link revertToCheckpoint}. */
     rollbackToCommit(commitId: string, _confirm?: boolean): Promise<{
         rolled_back_commits: string[];
         current_tip: string;
     }>;
+    applyCheckpoint(checkpointId: string, message?: string, author?: string): Promise<CheckpointRecord>;
+    /** @deprecated Use {@link applyCheckpoint}. */
     cherryPick(commitId: string, message?: string, author?: string): Promise<CommitRecord>;
+    createBookmark(name: string, checkpointId: string, message?: string, author?: string): Promise<BookmarkRecord>;
+    /** @deprecated Use {@link createBookmark}. */
     createTag(name: string, commitId: string, message?: string, author?: string): Promise<TagRecord>;
+    listBookmarks(options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        bookmarks: BookmarkRecord[];
+        total: number;
+    }>;
+    /** @deprecated Use {@link listBookmarks}. */
     listTags(options?: {
         limit?: number;
         offset?: number;
@@ -322,23 +364,44 @@ export declare class XCiteDBClient {
         tags: TagRecord[];
         total: number;
     }>;
+    getBookmark(name: string): Promise<BookmarkRecord>;
+    /** @deprecated Use {@link getBookmark}. */
     getTag(name: string): Promise<TagRecord>;
+    deleteBookmark(name: string): Promise<void>;
+    /** @deprecated Use {@link deleteBookmark}. */
     deleteTag(name: string): Promise<void>;
+    compare(from: CompareRef, to: CompareRef, includeContent?: boolean): Promise<CompareResult>;
+    /** @deprecated Use {@link compare}. */
     diff(from: DiffRef, to: DiffRef, includeContent?: boolean): Promise<DiffResult>;
+    publishWorkspace(targetWorkspace: string, sourceWorkspace: string, options?: {
+        message?: string;
+        autoResolve?: 'none' | 'source' | 'target';
+    }): Promise<PublishResult>;
+    /** @deprecated Use {@link publishWorkspace}. */
     mergeBranch(targetBranch: string, sourceBranch: string, options?: {
         message?: string;
         autoResolve?: 'none' | 'source' | 'target';
     }): Promise<MergeResult>;
     /**
-     * Create `branchName` from {@link options.fromBranch} (or current context branch), run `fn` scoped to that branch,
-     * create a commit, then merge back into the parent branch unless {@link options.autoMerge} is `false`.
-     * Restores previous {@link DatabaseContext} afterward.
+     * Create `workspaceName` from {@link options.fromBranch} (or current context), run `fn` scoped to that workspace,
+     * create a checkpoint, then publish back unless {@link options.autoMerge} is `false`.
      */
+    withWorkspace<T>(workspaceName: string, fn: (client: XCiteDBClient) => Promise<T>, options?: {
+        message?: string;
+        /** When true (default), publish `workspaceName` into the parent workspace after checkpoint. */
+        autoMerge?: boolean;
+        /** Workspace to fork from (default: current `context.branch` / `context.workspace`, or `""`). */
+        fromBranch?: string;
+        author?: string;
+    }): Promise<{
+        result: T;
+        checkpoint?: CheckpointRecord;
+        publish?: PublishResult;
+    }>;
+    /** @deprecated Use {@link withWorkspace}. */
     withBranch<T>(branchName: string, fn: (client: XCiteDBClient) => Promise<T>, options?: {
         message?: string;
-        /** When true (default), merge `branchName` into the parent branch after commit. */
         autoMerge?: boolean;
-        /** Branch to fork from (default: current `context.branch`, or `""`). */
         fromBranch?: string;
         author?: string;
     }): Promise<{

package/dist/client.js

@@ -345,7 +345,11 @@ class XCiteDBClient {
         this.projectId = projectId;
     }
     setContext(ctx) {
-        this.defaultContext = { ...this.defaultContext, ...ctx };
+        const next = { ...this.defaultContext, ...ctx };
+        if (ctx.workspace !== undefined) {
+            next.branch = ctx.workspace;
+        }
+        this.defaultContext = next;
     }
     setTokens(access, refresh) {
         this.accessToken = access;
@@ -367,8 +371,9 @@ class XCiteDBClient {
     contextHeaders() {
         const h = {};
         const c = this.defaultContext;
-        if (c.branch)
-            h['X-Branch'] = c.branch;
+        const ws = c.workspace ?? c.branch;
+        if (ws)
+            h['X-Workspace'] = ws;
         if (c.date)
             h['X-Date'] = c.date;
         if (c.prefix)
@@ -941,121 +946,202 @@ class XCiteDBClient {
         }
         return cfg;
     }
-    async createBranch(name, fromBranch, fromDate) {
+    async createWorkspace(name, fromBranch, fromDate) {
         const body = { name };
         if (fromBranch)
             body.from_branch = fromBranch;
         if (fromDate)
             body.from_date = fromDate;
-        await this.request('POST', '/api/v1/branches', body);
+        await this.request('POST', '/api/v1/workspaces', body);
+    }
+    /** @deprecated Use {@link createWorkspace}. */
+    async createBranch(name, fromBranch, fromDate) {
+        return this.createWorkspace(name, fromBranch, fromDate);
+    }
+    async deleteWorkspace(name) {
+        await this.request('DELETE', `/api/v1/workspaces/${encodeURIComponent(name)}`);
     }
+    /** @deprecated Use {@link deleteWorkspace}. */
     async deleteBranch(name) {
-        await this.request('DELETE', `/api/v1/branches/${encodeURIComponent(name)}`);
+        return this.deleteWorkspace(name);
+    }
+    async deleteWorkspaceRevision(workspace, date) {
+        await this.request('DELETE', `/api/v1/workspaces/${encodeURIComponent(workspace)}/revisions/${encodeURIComponent(date)}`);
     }
+    /** @deprecated Use {@link deleteWorkspaceRevision}. */
     async deleteRevision(branch, date) {
-        await this.request('DELETE', `/api/v1/branches/${encodeURIComponent(branch)}/revisions/${encodeURIComponent(date)}`);
+        return this.deleteWorkspaceRevision(branch, date);
     }
+    async listWorkspaces() {
+        const r = await this.request('GET', '/api/v1/workspaces');
+        return r.workspaces ?? r.branches ?? [];
+    }
+    /** @deprecated Use {@link listWorkspaces}. */
     async listBranches() {
-        const r = await this.request('GET', '/api/v1/branches');
-        return r.branches ?? [];
+        return this.listWorkspaces();
+    }
+    async getWorkspace(name) {
+        const r = await this.request('GET', `/api/v1/workspaces/${encodeURIComponent(name)}`);
+        return (r.workspace ?? r.branch);
     }
+    /** @deprecated Use {@link getWorkspace}. */
     async getBranch(name) {
-        const r = await this.request('GET', `/api/v1/branches/${encodeURIComponent(name)}`);
-        return r.branch;
+        return this.getWorkspace(name);
     }
-    async createCommit(message, author) {
+    async createCheckpoint(message, author) {
         const body = { message };
         if (author)
             body.author = author;
-        const r = await this.request('POST', '/api/v1/commits', body);
-        return r.commit;
+        const r = await this.request('POST', '/api/v1/checkpoints', body);
+        return (r.checkpoint ?? r.commit);
     }
-    async listCommits(options) {
+    /** @deprecated Use {@link createCheckpoint}. */
+    async createCommit(message, author) {
+        return this.createCheckpoint(message, author);
+    }
+    async listCheckpoints(options) {
         const q = buildQuery({
             branch: options?.branch,
             limit: options?.limit,
             offset: options?.offset,
         });
-        return this.request('GET', `/api/v1/commits${q}`);
+        const r = await this.request('GET', `/api/v1/checkpoints${q}`);
+        const list = r.checkpoints ?? r.commits ?? [];
+        return { checkpoints: list, total: r.total, branch: r.branch };
+    }
+    /** @deprecated Use {@link listCheckpoints}. */
+    async listCommits(options) {
+        const r = await this.listCheckpoints(options);
+        return { commits: r.checkpoints, total: r.total, branch: r.branch };
     }
+    async getCheckpoint(checkpointId) {
+        const r = await this.request('GET', `/api/v1/checkpoints/${encodeURIComponent(checkpointId)}`);
+        return (r.checkpoint ?? r.commit);
+    }
+    /** @deprecated Use {@link getCheckpoint}. */
     async getCommit(commitId) {
-        const r = await this.request('GET', `/api/v1/commits/${encodeURIComponent(commitId)}`);
-        return r.commit;
+        return this.getCheckpoint(commitId);
     }
-    async rollbackToCommit(commitId, _confirm) {
-        return this.request('POST', `/api/v1/commits/${encodeURIComponent(commitId)}/rollback`, {
+    async revertToCheckpoint(checkpointId, _confirm) {
+        return this.request('POST', `/api/v1/checkpoints/${encodeURIComponent(checkpointId)}/revert`, {
             confirm: true,
         });
     }
-    async cherryPick(commitId, message, author) {
+    /** @deprecated Use {@link revertToCheckpoint}. */
+    async rollbackToCommit(commitId, _confirm) {
+        const r = await this.revertToCheckpoint(commitId, _confirm);
+        return {
+            rolled_back_commits: r.rolled_back_commits ?? r.rolled_back_checkpoints,
+            current_tip: r.current_tip,
+        };
+    }
+    async applyCheckpoint(checkpointId, message, author) {
         const body = {};
         if (message)
             body.message = message;
         if (author)
             body.author = author;
-        const r = await this.request('POST', `/api/v1/commits/${encodeURIComponent(commitId)}/cherry-pick`, body);
-        return r.commit;
+        const r = await this.request('POST', `/api/v1/checkpoints/${encodeURIComponent(checkpointId)}/apply`, body);
+        return (r.checkpoint ?? r.commit);
     }
-    async createTag(name, commitId, message, author) {
-        const body = { name, commit_id: commitId };
+    /** @deprecated Use {@link applyCheckpoint}. */
+    async cherryPick(commitId, message, author) {
+        return this.applyCheckpoint(commitId, message, author);
+    }
+    async createBookmark(name, checkpointId, message, author) {
+        const body = { name, checkpoint_id: checkpointId };
         if (message)
             body.message = message;
         if (author)
             body.author = author;
-        const r = await this.request('POST', '/api/v1/tags', body);
-        return r.tag;
+        const r = await this.request('POST', '/api/v1/bookmarks', body);
+        return (r.bookmark ?? r.tag);
     }
-    async listTags(options) {
+    /** @deprecated Use {@link createBookmark}. */
+    async createTag(name, commitId, message, author) {
+        return this.createBookmark(name, commitId, message, author);
+    }
+    async listBookmarks(options) {
         const q = buildQuery({ limit: options?.limit, offset: options?.offset });
-        return this.request('GET', `/api/v1/tags${q}`);
+        const r = await this.request('GET', `/api/v1/bookmarks${q}`);
+        const list = r.bookmarks ?? r.tags ?? [];
+        return { bookmarks: list, total: r.total };
     }
+    /** @deprecated Use {@link listBookmarks}. */
+    async listTags(options) {
+        const r = await this.listBookmarks(options);
+        return { tags: r.bookmarks, total: r.total };
+    }
+    async getBookmark(name) {
+        const r = await this.request('GET', `/api/v1/bookmarks/${encodeURIComponent(name)}`);
+        return (r.bookmark ?? r.tag);
+    }
+    /** @deprecated Use {@link getBookmark}. */
     async getTag(name) {
-        const r = await this.request('GET', `/api/v1/tags/${encodeURIComponent(name)}`);
-        return r.tag;
+        return this.getBookmark(name);
     }
+    async deleteBookmark(name) {
+        await this.request('DELETE', `/api/v1/bookmarks/${encodeURIComponent(name)}`);
+    }
+    /** @deprecated Use {@link deleteBookmark}. */
     async deleteTag(name) {
-        await this.request('DELETE', `/api/v1/tags/${encodeURIComponent(name)}`);
+        return this.deleteBookmark(name);
     }
-    async diff(from, to, includeContent) {
-        return this.request('POST', '/api/v1/diff', {
+    async compare(from, to, includeContent) {
+        return this.request('POST', '/api/v1/compare', {
             from,
             to,
             include_content: includeContent ?? false,
         });
     }
-    async mergeBranch(targetBranch, sourceBranch, options) {
-        const body = { source_branch: sourceBranch };
+    /** @deprecated Use {@link compare}. */
+    async diff(from, to, includeContent) {
+        return this.compare(from, to, includeContent);
+    }
+    async publishWorkspace(targetWorkspace, sourceWorkspace, options) {
+        const body = {
+            source_workspace: sourceWorkspace,
+            source_branch: sourceWorkspace,
+        };
         if (options?.message)
             body.message = options.message;
         body.auto_resolve = options?.autoResolve ?? 'none';
-        return this.request('POST', `/api/v1/branches/${encodeURIComponent(targetBranch)}/merge`, body);
+        return this.request('POST', `/api/v1/workspaces/${encodeURIComponent(targetWorkspace)}/publish`, body);
+    }
+    /** @deprecated Use {@link publishWorkspace}. */
+    async mergeBranch(targetBranch, sourceBranch, options) {
+        return this.publishWorkspace(targetBranch, sourceBranch, options);
     }
     /**
-     * Create `branchName` from {@link options.fromBranch} (or current context branch), run `fn` scoped to that branch,
-     * create a commit, then merge back into the parent branch unless {@link options.autoMerge} is `false`.
-     * Restores previous {@link DatabaseContext} afterward.
+     * Create `workspaceName` from {@link options.fromBranch} (or current context), run `fn` scoped to that workspace,
+     * create a checkpoint, then publish back unless {@link options.autoMerge} is `false`.
      */
-    async withBranch(branchName, fn, options) {
+    async withWorkspace(workspaceName, fn, options) {
         const prev = { ...this.defaultContext };
-        const fromBranch = options?.fromBranch ?? prev.branch ?? '';
-        let commit;
-        let merge;
+        const fromWs = options?.fromBranch ?? prev.branch ?? prev.workspace ?? '';
+        let checkpoint;
+        let publish;
         try {
-            await this.createBranch(branchName, fromBranch || undefined, prev.date || undefined);
-            this.setContext({ branch: branchName });
+            await this.createWorkspace(workspaceName, fromWs || undefined, prev.date || undefined);
+            this.setContext({ workspace: workspaceName, branch: workspaceName });
             const result = await fn(this);
-            commit = await this.createCommit(options?.message ?? `Branch ${branchName}`, options?.author);
+            checkpoint = await this.createCheckpoint(options?.message ?? `Workspace ${workspaceName}`, options?.author);
             if (options?.autoMerge !== false) {
-                merge = await this.mergeBranch(fromBranch, branchName, {
+                publish = await this.publishWorkspace(fromWs, workspaceName, {
                     message: options?.message,
                 });
             }
-            return { result, commit, merge };
+            return { result, checkpoint, publish };
         }
         finally {
             this.setContext(prev);
         }
     }
+    /** @deprecated Use {@link withWorkspace}. */
+    async withBranch(branchName, fn, options) {
+        const r = await this.withWorkspace(branchName, fn, options);
+        return { result: r.result, commit: r.checkpoint, merge: r.publish };
+    }
     /** Send raw XML body (`Content-Type: application/xml`). For JSON wrapper + options use `writeXmlDocument`. */
     async writeXML(xml, _options) {
         const payload = this.isoApplyXmlDbIdentifier(xml);

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { XCiteDBClient } from './client';
 export { WebSocketSubscription } from './websocket';
-export type { AccessCheckResult, ApiKeyInfo, AppAuthConfig, AppEmailConfig, AppEmailSmtpConfig, AppEmailTemplateEntry, AppEmailTemplates, AppEmailWebhookConfig, AppUser, AppUserTokenPair, EmailTestResponse, ForgotPasswordResponse, SendVerificationResponse, DatabaseContext, Flags, JsonDocumentData, IdentifierChildNode, ListIdentifierChildrenResult, ListIdentifiersResult, LockInfo, OAuthProviderInfo, OAuthProvidersResponse, OwnedTenantInfo, ProjectInfo, PlatformRegistrationConfig, PlatformWorkspaceOrg, PlatformWorkspacesResponse, ProjectSearchSettings, ProjectSearchSettingsUpdate, LogEntry, MetaValue, PlatformRegisterResult, PolicyUpdateResponse, PolicyConditions, PolicyIdentifierPattern, PolicyResources, PolicySubjectInput, PolicySubjects, RagQueryOptions, RagQueryResult, RagStreamEvent, RealtimeEvent, SearchIndexingProgress, SecurityConfig, SecurityPolicy, StoredPolicyResponse, StoredTriggerResponse, SubscriptionOptions, TextSearchHit, TextSearchQuery, TextSearchResult, TriggerDefinition, TokenPair, UserInfo, UserIsolationConfig, UserIsolationOptions, WriteDocumentOptions, CreateTestSessionOptions, XCiteDBClientOptions, XCiteDBJwtClaims, UnqueryResult, UnqueryTemplate, XCiteQuery, } from './types';
+export type { AccessCheckResult, ApiKeyInfo, AppAuthConfig, AppEmailConfig, AppEmailSmtpConfig, AppEmailTemplateEntry, AppEmailTemplates, AppEmailWebhookConfig, AppUser, AppUserTokenPair, EmailTestResponse, ForgotPasswordResponse, SendVerificationResponse, BookmarkRecord, BranchInfo, BranchListItem, CheckpointRecord, CommitRecord, CompareEntry, CompareRef, CompareResult, DatabaseContext, DiffEntry, DiffRef, DiffResult, Flags, JsonDocumentData, IdentifierChildNode, ListIdentifierChildrenResult, ListIdentifiersResult, LockInfo, MergeConflict, MergeResult, OAuthProviderInfo, OAuthProvidersResponse, OwnedTenantInfo, ProjectInfo, PlatformRegistrationConfig, PlatformWorkspaceOrg, PlatformWorkspacesResponse, ProjectSearchSettings, ProjectSearchSettingsUpdate, LogEntry, MetaValue, PlatformRegisterResult, PolicyUpdateResponse, PublishConflict, PublishResult, PolicyConditions, PolicyIdentifierPattern, PolicyResources, PolicySubjectInput, PolicySubjects, RagQueryOptions, RagQueryResult, RagStreamEvent, RealtimeEvent, SearchIndexingProgress, SecurityConfig, SecurityPolicy, StoredPolicyResponse, StoredTriggerResponse, SubscriptionOptions, TagRecord, TextSearchHit, TextSearchQuery, TextSearchResult, TriggerDefinition, TokenPair, UserInfo, UserIsolationConfig, UserIsolationOptions, WorkspaceInfo, WriteDocumentOptions, CreateTestSessionOptions, XCiteDBClientOptions, XCiteDBJwtClaims, UnqueryResult, UnqueryTemplate, XCiteQuery, } from './types';
 export { XCiteDBError } from './types';

package/dist/types.d.ts

@@ -307,6 +307,12 @@ export interface ApiKeyInfo {
 }
 export type Flags = 'None' | 'FirstMatch' | 'IncludeChildren' | 'NoChildren' | 'KeepIndexNodes' | 'PrevIfDeleted' | string;
 export interface DatabaseContext {
+    /**
+     * Workspace name (isolated editing environment). Empty / unset = main timeline.
+     * Sent as `X-Workspace` (preferred); see also {@link DatabaseContext.branch}.
+     */
+    workspace?: string;
+    /** @deprecated Prefer {@link DatabaseContext.workspace}. Sent as `X-Branch` when `workspace` is unset. */
     branch?: string;
     date?: string;
     prefix?: string;
@@ -596,83 +602,115 @@ export interface StoredTriggerResponse {
     trigger_id: string;
     trigger: TriggerDefinition;
 }
-/** Version control / commit metadata (git-like layer). */
-export interface CommitRecord {
+/** Named snapshot on a workspace (checkpoint). */
+export interface CheckpointRecord {
     id: string;
+    /** Same as `id` when returned by newer APIs. */
+    checkpoint_id?: string;
     branch: string;
-    /** Internal LMDB date key for this commit snapshot. */
-    date_key: string;
-    date_human?: string;
-    /** Alias for human-readable date (same as date_human when present). */
+    /** Human-readable revision date/time. */
     date?: string;
+    date_human?: string;
+    /** @deprecated Internal key; omitted from newer API responses. */
+    date_key?: string;
     message: string;
     author: string;
     parent_id: string | null;
     merge_source?: {
         branch: string;
-        commit_id: string;
+        checkpoint_id?: string;
+        commit_id?: string;
     };
     cherry_picked_from?: string;
     affected_identifiers: string[];
     status: 'active' | 'rolled_back';
     created_at: number;
 }
-/** Branch row from GET /api/v1/branches (also exposed as BranchListItem). */
-export interface BranchInfo {
+/** @deprecated Use {@link CheckpointRecord}. */
+export type CommitRecord = CheckpointRecord;
+/** Workspace row from `GET /api/v1/workspaces` (legacy: `/api/v1/branches`). */
+export interface WorkspaceInfo {
     name: string;
     from_branch: string;
     from_date: string;
-    /** Internal LMDB fork date key when present. */
-    from_date_key?: string;
-    tip_commit?: CommitRecord;
-}
-export type BranchListItem = BranchInfo;
-export interface TagRecord {
+    tip_checkpoint?: CheckpointRecord;
+    /** @deprecated Alias of {@link WorkspaceInfo.tip_checkpoint}. */
+    tip_commit?: CheckpointRecord;
+}
+/** @deprecated Use {@link WorkspaceInfo}. */
+export type BranchInfo = WorkspaceInfo;
+/** @deprecated Use {@link WorkspaceInfo}. */
+export type BranchListItem = WorkspaceInfo;
+export interface BookmarkRecord {
     name: string;
-    commit_id: string;
+    checkpoint_id: string;
+    /** @deprecated Same as `checkpoint_id`. */
+    commit_id?: string;
     branch: string;
-    date_key: string;
+    date?: string;
+    /** @deprecated */
+    date_key?: string;
     message?: string;
     author?: string;
     created_at: number;
 }
-export interface DiffEntry {
+/** @deprecated Use {@link BookmarkRecord}. */
+export type TagRecord = BookmarkRecord;
+export interface CompareEntry {
     identifier: string;
     action: 'added' | 'modified' | 'deleted';
     from_content?: string;
     to_content?: string;
 }
-export interface DiffRef {
+/** @deprecated Use {@link CompareEntry}. */
+export type DiffEntry = CompareEntry;
+export interface CompareRef {
     branch?: string;
-    /** Internal date key (preferred for exact revision). */
+    /** Human-readable date (preferred). */
+    date?: string;
+    checkpoint_id?: string;
+    /** @deprecated Undocumented fallback. */
     date_key?: string;
+    /** @deprecated Use {@link CompareRef.checkpoint_id}. */
     commit_id?: string;
 }
-export interface DiffResult {
-    changes: DiffEntry[];
+/** @deprecated Use {@link CompareRef}. */
+export type DiffRef = CompareRef;
+export interface CompareResult {
+    changes: CompareEntry[];
     from: {
         branch?: string;
+        date?: string;
         date_key?: string;
     };
     to: {
         branch?: string;
+        date?: string;
         date_key?: string;
     };
     total_changes: number;
 }
-export interface MergeConflict {
+/** @deprecated Use {@link CompareResult}. */
+export type DiffResult = CompareResult;
+export interface PublishConflict {
     identifier: string;
     source_action: string;
     target_action: string;
 }
-export interface MergeResult {
+/** @deprecated Use {@link PublishConflict}. */
+export type MergeConflict = PublishConflict;
+export interface PublishResult {
     status: 'completed' | 'conflicts';
-    commit?: CommitRecord;
+    checkpoint?: CheckpointRecord;
+    /** @deprecated Alias of {@link PublishResult.checkpoint}. */
+    commit?: CheckpointRecord;
     merged_identifiers?: string[];
-    conflicts?: MergeConflict[];
+    conflicts?: PublishConflict[];
     auto_mergeable?: string[];
     message?: string;
 }
+/** @deprecated Use {@link PublishResult}. */
+export type MergeResult = PublishResult;
 export declare class XCiteDBError extends Error {
     readonly status: number;
     readonly body?: unknown | undefined;

package/llms-full.txt

@@ -8,13 +8,13 @@
 
 Before reading the full reference, note these critical differences from typical databases:
 
-1. **The default branch is the empty string `""`, not `"main"`.** When no `X-Branch` header is sent (or `context.branch` is omitted/empty), the server operates on the root timeline. A branch named `"main"` may exist as a user-created branch, but it is not required or special.
+1. **The default workspace is the empty string `""`, not `"main"`.** When no `X-Workspace` header is sent (or `context.workspace` / `context.branch` is omitted/empty), the server operates on the root timeline. `X-Branch` is a supported alias of `X-Workspace`. A workspace named `"main"` may exist as user-created metadata, but it is not required or special.
 
 2. **Identifiers are hierarchical, path-like strings** — e.g. `/us/bills/hr1`, `/manual/v2/chapter3`. They are NOT auto-generated UUIDs. The leading `/` is part of the identifier. Parent/child relationships are derived from the path structure.
 
 3. **Documents are XML or JSON, not arbitrary blobs.** XML documents are the primary document type. JSON documents are a parallel store. Both are fully versioned.
 
-4. **Context (branch + date) travels as HTTP headers** (`X-Branch`, `X-Date`, and optionally `X-Unversioned` for explicit flat writes), not URL path segments.
+4. **Context (workspace + date) travels as HTTP headers** (`X-Workspace` preferred, `X-Branch` alias, `X-Date`, and optionally `X-Unversioned` for explicit flat writes), not URL path segments.
 
 5. **XML documents carry their identifier inside the XML** via a `db:identifier` attribute on the root element.
 
@@ -28,6 +28,16 @@ Before reading the full reference, note these critical differences from typical
 
 10. **Ephemeral test sessions.** `POST /api/v1/test/sessions` (authenticated) returns a UUID **`session_token`**. Clients send **`X-Test-Session: <token>`** on API calls to use an isolated, TTL- and quota-limited LMDB instead of production project data. Unless **`X-Test-Auth: required`** is set, **developer** JWT/API-key checks are bypassed (synthetic admin for wet tests), but **app-user** identity via **`X-App-User-Token`** or Bearer app-user JWT is still recognized. Management routes under **`/api/v1/test/*`** must not include `X-Test-Session`. The test store starts empty (no cloned production project config).
 
+## Choosing the Right Versioning Approach
+
+- **Write at a specific date:** Set `X-Date` / `context.date` and write — every dated write is a **temporal revision**; no workspace or checkpoint required.
+- **Read as-of a date:** Set `X-Date` and read; the engine returns the revision at or before that instant.
+- **Isolated editing (draft → publish):** Create a **workspace**, edit, then **publish** to the target timeline; optional **checkpoints** for named snapshots.
+- **Audit trail:** Checkpoints carry messages and affected identifiers; **bookmarks** name a checkpoint.
+- **Undo a batch:** **Revert** to a prior checkpoint on that workspace.
+
+Legacy REST paths under `/api/v1/branches`, `/commits`, `/tags`, `/diff` remain **deprecated** aliases; prefer **`/api/v1/workspaces`**, **`/checkpoints`**, **`/bookmarks`**, **`/compare`**.
+
 ## Common Pitfalls
 
 1. **`baseUrl` must be origin-only (no `/api` or `/api/v1` path).** The SDK prepends `/api/v1/…` to every request. If `baseUrl` is `https://host/api/v1`, requests hit `/api/v1/api/v1/…` which typically returns **405 Not Allowed** from the reverse proxy. Use only the scheme + host + optional port: `https://host` or `http://localhost:8080`.
@@ -65,25 +75,25 @@ Before reading the full reference, note these critical differences from typical
 ### 1.1 What is XciteDB?
 XciteDB is an enterprise-grade **Backend-as-a-Service (BaaS)** built on top of a highly optimized **embedded LMDB** database engine. Powered by a high-performance C++17 HTTP/WebSocket API, XciteDB exposes a multi-tenant, secure platform for managing complex, versioned, structured documents.
 
-**Both XML and JSON are first-class citizens.** XciteDB can operate as a pure **XML document store**, a pure **JSON document database**, or any combination of the two — including the common pattern of **XML documents enriched with structured JSON metadata**. In every mode, data is deeply shredded into its structural components (elements, attributes, objects, fields, array items), versioned, branched, indexed by path, and fully queryable through the same Unquery analytics engine.
+**Both XML and JSON are first-class citizens.** XciteDB can operate as a pure **XML document store**, a pure **JSON document database**, or any combination of the two — including the common pattern of **XML documents enriched with structured JSON metadata**. In every mode, data is deeply shredded into its structural components (elements, attributes, objects, fields, array items), versioned, indexed by path, and fully queryable through the same Unquery analytics engine — with **temporal revisions**, **workspaces**, and **checkpoints** when you need collaborative workflow.
 
 ### 1.2 The Problem It Solves
 Standard relational databases and generic NoSQL stores struggle with highly structured, hierarchical, and deeply versioned content. Building collaborative authoring tools, legislative drafting systems, or complex content management platforms usually requires bolting a Git-like versioning layer and document-aware parsers onto an ill-fitting database.
 
-XciteDB bridges this gap. It provides **Git-like versioning for structured XML and JSON data** out of the box, delivered as a modern, API-first cloud platform with multi-tenancy, Attribute-Based Access Control (ABAC), and S3-compatible backups.
+XciteDB bridges this gap. It provides **temporal versioning plus optional workspaces and checkpoints** for structured XML and JSON data out of the box, delivered as a modern, API-first cloud platform with multi-tenancy, Attribute-Based Access Control (ABAC), and S3-compatible backups.
 
 ### 1.3 Target Workloads
 XciteDB shines in domains requiring strict auditability, collaborative authoring, and complex document hierarchies:
 - **Legal and Legislative Drafting:** Tracking amendments, clauses, and exact historical states of laws.
 - **Structured Technical Documentation:** Managing manuals, specifications, and compliance documents where every change must be versioned and attributable.
-- **Collaborative Content Management:** Systems requiring branching, merging, and cooperative locking to prevent editor conflicts.
+- **Collaborative Content Management:** Systems requiring isolated workspaces, publish workflows, and cooperative locking to prevent editor conflicts.
 - **Application State and Configuration:** Storing deeply structured JSON configuration, feature flags, or workflow state that benefits from versioning and path-level querying.
 
 ### 1.4 Unique Differentiators
-- **First-Class XML & JSON:** Both formats are shredded, indexed by path, versioned, branched, and fully queryable through the same engine.
+- **First-Class XML & JSON:** Both formats are shredded, indexed by path, versioned, and fully queryable through the same engine.
 - **Embedded LMDB Engine:** A memory-mapped, ACID-compliant storage core purpose-built for structured document workloads.
 - **Bare-Metal Speed:** Reads hit memory-mapped pages with no network round-trip. Microsecond-class read latency on warm data.
-- **"Git for Data" Versioning:** Branches, commits, tags, diffs, and time-travel are first-class database primitives.
+- **Document-centric versioning:** Temporal revisions (`X-Date`), workspaces, checkpoints, bookmarks, compare, publish, revert, and apply — plus time-travel reads.
 - **Unquery DSL:** A purpose-built declarative query language for navigating, filtering, and aggregating data across both XML trees and JSON structures.
 - **Native Office Ingestion:** Directly convert and ingest DOCX, ODF, RTF, and PDF formats into clean, versioned XML documents.
 - **Transparent Tenant Routing:** Scale out horizontally using a coordinator/worker topology without breaking the client API contract.
@@ -106,10 +116,10 @@ XciteDB shines in domains requiring strict auditability, collaborative authoring
 - **JSON Metadata on XML:** JSON metadata can be attached to any XML document or path.
 - **Hierarchical Identifiers:** Both XML and JSON documents are addressed via logical, path-like strings. The engine natively indexes parent/child relationships.
 
-### 2.3 Git-Like Document Versioning
-- **Branches & Commits:** Isolate collaborative edits into branches. Create atomic commits with descriptive messages.
-- **Merge & Cherry-Pick:** Merge branches or cherry-pick specific commits.
-- **Time Travel:** Read historical state at any point in time using the `X-Date` header. For **writes**, `X-Unversioned: true` explicitly requests flat (unversioned) storage; it conflicts with `X-Date` (**400**).
+### 2.3 Document versioning model
+- **Temporal revisions & workspaces:** Every write with `X-Date` records under that revision instant. **Workspaces** isolate draft edits from the root timeline.
+- **Checkpoints, publish, apply, revert:** Optional named snapshots (**checkpoints**); **publish** merges a workspace into a target; **apply** brings another checkpoint’s changes; **revert** rolls the workspace back to a checkpoint.
+- **Time travel:** Read historical state at any point in time using the `X-Date` header. For **writes**, `X-Unversioned: true` explicitly requests flat (unversioned) storage; it conflicts with `X-Date` (**400**).
 - **Cooperative Locking:** TTL locks prevent conflicting writes (HTTP 409 on conflict).
 
 ### 2.4 Unquery: Declarative Query DSL
@@ -142,7 +152,8 @@ Welcome to the **XciteDB HTTP API**. This reference describes REST endpoints und
 |--------|------|-------------|
 | `Authorization` | Usually required | `Bearer <JWT>` or `Bearer <api_key>` |
 | `X-Project-Id` | Platform console / multi-project JWT | Selects the **tenant project** when the token is not already bound to one tenant |
-| `X-Branch` | Optional | Active branch name for document and versioning operations |
+| `X-Workspace` | Optional | Active workspace name for document and versioning operations (preferred) |
+| `X-Branch` | Optional | Deprecated alias of `X-Workspace` |
 | `X-Date` | Optional | Point-in-time / revision context (ISO-like string as used by your deployment) |
 | `X-Unversioned` | Optional | When `true` or `1`, **writes** use flat LMDB keys (no date revision). Must not be combined with `X-Date` (**400**). Omitting `X-Date` remains valid (implicit unversioned). |
 
@@ -241,8 +252,8 @@ describe('XciteDB integration', () => {
     expect(xml).toContain('<title>Hello</title>');
   });
 
-  it('creates a branch, commits, and merges', async () => {
-    await client.withBranch('feature-test', async (c) => {
+  it('creates a workspace, checkpoints, and publishes', async () => {
+    await client.withWorkspace('feature-test', async (c) => {
       await c.writeJsonDocument('test.feature', { active: true });
     }, { message: 'Add feature flag', autoMerge: true });
     const doc = await client.readJsonDocument<{ active: boolean }>('test.feature');
@@ -283,8 +294,8 @@ async def test_xml_document(db):
     assert "<title>Hello</title>" in result
 
 @pytest.mark.asyncio
-async def test_branch_and_merge(db):
-    async with db.with_branch("feature-test", message="Add flag", auto_merge=True):
+async def test_workspace_and_publish(db):
+    async with db.with_workspace("feature-test", message="Add flag", auto_merge=True):
         await db.put("test.feature", {"active": True})
     doc = await db.get("test.feature")
     assert doc["active"] is True
@@ -518,7 +529,7 @@ Can also use `"query"` instead of `"identifier"` to target multiple documents by
 
 # Search
 
-Full-text search uses embedded XciteFTS (enable per project in server settings).
+Full-text search (backed by Meilisearch or Elasticsearch).
 
 **Base path:** `/api/v1/search`
 
@@ -680,100 +691,107 @@ Dry-run: **`POST /api/v1/security/check`** with `subject`, `identifier`, `action
 
 ---
 
-# Branches
+# Workspaces (branches)
 
-**Base path:** `/api/v1/branches`
+**Preferred base path:** `/api/v1/workspaces`  
+**Deprecated alias:** `/api/v1/branches` (same handlers)
 
-**IMPORTANT: The default branch is the empty string `""`.** When no branch is specified, the server uses the root timeline.
+**IMPORTANT: The default workspace is the empty string `""`.** When no workspace is specified, the server uses the root timeline.
 
-## List branches
+## List workspaces
 
-**`GET /api/v1/branches`** — Returns `{ branches: [{ name, from_branch, from_date, from_date_key, tip_commit }] }`.
+**`GET /api/v1/workspaces`** — Returns `{ workspaces: [...], branches: [...] }` where each item includes `name`, `from_branch`, `from_date`, `tip_checkpoint` (and `tip_commit` mirror).
 
-## Create branch
+## Create workspace
 
-**`POST /api/v1/branches`** — `{ "name": "feature-x", "from_branch": "", "from_date": "" }`
+**`POST /api/v1/workspaces`** — `{ "name": "feature-x", "from_branch": "", "from_date": "" }`
 
-## Get branch
+## Get workspace
 
-**`GET /api/v1/branches/{name}`** — Returns `{ branch: {...} }`.
+**`GET /api/v1/workspaces/{name}`** — Returns `{ workspace: {...}, branch: {...} }`.
 
-## Delete branch
+## Delete workspace
 
-**`DELETE /api/v1/branches/{name}`**
+**`DELETE /api/v1/workspaces/{name}`**
 
-## Merge branch
+## Publish workspace
 
-**`POST /api/v1/branches/{target}/merge`**
+**`POST /api/v1/workspaces/{target}/publish`**
 
 ```json
 {
+  "source_workspace": "feature-x",
   "source_branch": "feature-x",
-  "message": "Merge feature",
+  "message": "Publish feature",
   "auto_resolve": "none"
 }
 ```
 
 `auto_resolve`: `"none"` | `"source"` | `"target"`.
 
-Returns `{ status: "completed"|"conflicts", commit?, merged_identifiers?, conflicts? }`.
+Returns `{ status: "completed"|"conflicts", checkpoint?, commit?, merged_identifiers?, conflicts? }` (`commit` mirrors `checkpoint`).
 
-## Delete revision on branch
+## Delete revision on workspace
 
-**`DELETE /api/v1/branches/{name}/revisions/{date}`**
+**`DELETE /api/v1/workspaces/{name}/revisions/{date}`** (human-readable date in path; legacy `/branches/...` path still works)
 
 ---
 
-# Commits, tags & diff
+# Checkpoints, bookmarks & compare
 
-## Create commit
+## Create checkpoint
 
-**`POST /api/v1/commits`** — `{ "message": "...", "author": "..." }`
+**`POST /api/v1/checkpoints`** — `{ "message": "...", "author": "..." }`  
+(Deprecated: **`POST /api/v1/commits`**)
 
-Returns `{ commit: { id, branch, date_key, message, author, ... } }`.
+Returns `{ checkpoint: { id, checkpoint_id, branch, date, message, author, ... }, commit: <same> }`. Public JSON uses human-readable **`date`** (no `date_key`).
 
-## List commits
+## List checkpoints
 
-**`GET /api/v1/commits?branch=...&limit=...&offset=...`**
+**`GET /api/v1/checkpoints?branch=...&limit=...&offset=...`** (query param name unchanged; means workspace)  
+Returns `{ checkpoints: [...], commits: [...], total, branch }` (mirrors).
 
-Returns `{ commits: [...], total, branch }`.
+## Get checkpoint
 
-## Get commit
+**`GET /api/v1/checkpoints/{id}`** — Returns `{ checkpoint, commit }`.
 
-**`GET /api/v1/commits/{id}`** — Returns `{ commit: {...} }`.
+## Revert to checkpoint
 
-## Rollback to commit
+**`POST /api/v1/checkpoints/{id}/revert`** — `{ "confirm": true }`  
+(Deprecated: **`.../rollback`**)
 
-**`POST /api/v1/commits/{id}/rollback`** — `{ "confirm": true }`
+## Apply checkpoint
 
-## Cherry-pick commit
+**`POST /api/v1/checkpoints/{id}/apply`** — `{ "message": "...", "author": "..." }`  
+(Deprecated: **`.../cherry-pick`**)
 
-**`POST /api/v1/commits/{id}/cherry-pick`** — `{ "message": "...", "author": "..." }`
+## Create bookmark
 
-## Create tag
+**`POST /api/v1/bookmarks`** — `{ "name": "v1.0", "checkpoint_id": "...", "commit_id": "...", "message": "..." }`  
+(Deprecated: **`POST /api/v1/tags`**)
 
-**`POST /api/v1/tags`** — `{ "name": "v1.0", "commit_id": "...", "message": "..." }`
+## List bookmarks
 
-## List tags
+**`GET /api/v1/bookmarks?limit=...&offset=...`** — Returns `{ bookmarks: [...], tags: [...], total }` (mirrors where applicable).
 
-**`GET /api/v1/tags?limit=...&offset=...`** — Returns `{ tags: [...], total }`.
+## Get / Delete bookmark
 
-## Get / Delete tag
+**`GET /api/v1/bookmarks/{name}`** / **`DELETE /api/v1/bookmarks/{name}`** (deprecated `/tags/...`)
 
-**`GET /api/v1/tags/{name}`** / **`DELETE /api/v1/tags/{name}`**
+## Compare
 
-## Diff
-
-**`POST /api/v1/diff`**
+**`POST /api/v1/compare`**
 
 ```json
 {
-  "from": { "branch": "", "date_key": "..." },
+  "from": { "branch": "", "date": "2024-01-15T00:00:00" },
   "to": { "branch": "feature-x" },
   "include_content": true
 }
 ```
 
+(Deprecated: **`POST /api/v1/diff`**; `date_key` still accepted internally but prefer **`date`**.)
+
 Returns `{ changes: [{ identifier, action: "added"|"modified"|"deleted", from_content?, to_content? }], total_changes }`.
 
 ---
@@ -1243,7 +1261,7 @@ import { XCiteDBClient } from '@xcitedbs/client';
 const client = new XCiteDBClient({
   baseUrl: 'http://localhost:8080',
   apiKey: 'your-api-key',
-  context: { branch: '', date: '' },
+  context: { workspace: '', date: '' },
 });
 
 // Health check
@@ -1263,12 +1281,12 @@ await client.writeJsonDocument('app.settings', { theme: 'dark' });
 // Read JSON document
 const settings = await client.readJsonDocument('app.settings');
 
-// Branch, edit, commit, merge
-await client.createBranch('feature-x');
-client.setContext({ branch: 'feature-x' });
+// Workspace, edit, checkpoint, publish
+await client.createWorkspace('feature-x');
+client.setContext({ workspace: 'feature-x' });
 await client.writeJsonDocument('app.settings', { theme: 'light' });
-await client.createCommit('Switch to light theme');
-await client.mergeBranch('', 'feature-x');
+await client.createCheckpoint('Switch to light theme');
+await client.publishWorkspace('', 'feature-x');
 ```
 
 ## Constructor Options
@@ -1289,7 +1307,8 @@ interface XCiteDBClientOptions {
 }
 
 interface DatabaseContext {
-  branch?: string;   // '' = default (root timeline)
+  workspace?: string; // '' = default (root timeline); preferred
+  branch?: string;    // @deprecated alias of workspace
   date?: string;     // Point-in-time
   prefix?: string;   // Identifier prefix filter
   unversioned?: boolean; // Sends X-Unversioned: true (flat writes; do not combine with date)
@@ -1357,30 +1376,34 @@ interface DatabaseContext {
 - `queryMetaByQuery<T>(query, path?)` → `T`
 - `clearMeta(query)` → `boolean`
 
-### Branches
-- `withBranch(name, fn, options?)` → `{ result, commit?, merge? }` — branch, callback, commit, merge back
-- `createBranch(name, fromBranch?, fromDate?)` → `void`
-- `listBranches()` → `BranchInfo[]`
-- `getBranch(name)` → `BranchInfo`
-- `deleteBranch(name)` → `void`
-- `deleteRevision(branch, date)` → `void`
-- `mergeBranch(targetBranch, sourceBranch, options?)` → `MergeResult`
-
-### Commits
-- `createCommit(message, author?)` → `CommitRecord`
-- `listCommits(options?)` → `{ commits, total, branch }`
-- `getCommit(commitId)` → `CommitRecord`
-- `rollbackToCommit(commitId)` → `{ rolled_back_commits, current_tip }`
-- `cherryPick(commitId, message?, author?)` → `CommitRecord`
-
-### Tags
-- `createTag(name, commitId, message?, author?)` → `TagRecord`
-- `listTags(options?)` → `{ tags, total }`
-- `getTag(name)` → `TagRecord`
-- `deleteTag(name)` → `void`
-
-### Diff
-- `diff(from: DiffRef, to: DiffRef, includeContent?)` → `DiffResult`
+### Workspaces & checkpoints
+- `withWorkspace(name, fn, options?)` → `{ result, checkpoint?, publish? }` — workspace, callback, checkpoint, publish back
+- `createWorkspace(name, fromBranch?, fromDate?)` → `void`
+- `listWorkspaces()` → `WorkspaceInfo[]`
+- `getWorkspace(name)` → `WorkspaceInfo`
+- `deleteWorkspace(name)` → `void`
+- `deleteRevision(branch, date)` → `void` (workspace name + human date)
+- `publishWorkspace(targetWorkspace, sourceWorkspace, options?)` → `PublishResult`
+- **Deprecated:** `withBranch`, `createBranch`, `listBranches`, `getBranch`, `deleteBranch`, `mergeBranch` (same HTTP behavior)
+
+### Checkpoints
+- `createCheckpoint(message, author?)` → `CheckpointRecord`
+- `listCheckpoints(options?)` → `{ checkpoints, total, branch }` (wire JSON may also include `commits` mirror)
+- `getCheckpoint(checkpointId)` → `CheckpointRecord`
+- `revertToCheckpoint(checkpointId)` → `{ rolled_back_checkpoints, rolled_back_commits?, current_tip }`
+- `applyCheckpoint(checkpointId, message?, author?)` → `CheckpointRecord`
+- **Deprecated:** `createCommit`, `listCommits`, `getCommit`, `rollbackToCommit`, `cherryPick`
+
+### Bookmarks
+- `createBookmark(name, checkpointId, message?, author?)` → `BookmarkRecord`
+- `listBookmarks(options?)` → `{ bookmarks, tags, total, limit?, offset? }`
+- `getBookmark(name)` → `BookmarkRecord`
+- `deleteBookmark(name)` → `void`
+- **Deprecated:** `createTag`, `listTags`, `getTag`, `deleteTag`
+
+### Compare
+- `compare(from: CompareRef, to: CompareRef, includeContent?)` → `CompareResult`
+- **Deprecated:** `diff(from: DiffRef, …)` — alias of `compare`
 
 ### Locks
 - `acquireLock(identifier, expires?)` → `LockInfo`
@@ -1513,7 +1536,7 @@ async def main():
     async with XCiteDBClient(
         "http://localhost:8080",
         api_key="your-key",
-        context=DatabaseContext(branch="", date=""),
+        context=DatabaseContext(workspace="", date=""),
     ) as client:
         print(await client.health())
         print(await client.query_documents(XCiteQuery(match_start="/manual/")))
@@ -1523,13 +1546,13 @@ async def main():
         print(await client.search(TextSearchQuery(query="guide", limit=10)))
         await client.platform_login("admin@localhost", "password")
         # await client.login_app_user("user@example.com", "pw")  # set context.project_id / tenant_id if needed
-        async with client.with_branch("feature-x", message="WIP", auto_merge=True):
+        async with client.with_workspace("feature-x", message="WIP", auto_merge=True):
             await client.put("app.settings", {"theme": "light"})
 
 asyncio.run(main())
 ```
 
-Async client: `write_xml_document` / `write_document_json` (deprecated), `write_json_document`, `read_json_document`, `list_json_documents`, `list_identifiers`, `search`, `reindex`, `platform_login` / `login` (deprecated), `login_app_user`, `refresh_app_user`, `logout_app_user`, `register_app_user`, `put` / `get` / `remove` / `list_documents` (JSON aliases), `with_branch` (async context manager).
+Async client: `write_xml_document` / `write_document_json` (deprecated), `write_json_document`, `read_json_document`, `list_json_documents`, `list_identifiers`, `search`, `reindex`, `platform_login` / `login` (deprecated), `login_app_user`, `refresh_app_user`, `logout_app_user`, `register_app_user`, `put` / `get` / `remove` / `list_documents` (JSON aliases), `with_workspace` (async context manager; `with_branch` deprecated alias).
 
 ---
 
@@ -1541,7 +1564,7 @@ Async client: `write_xml_document` / `write_document_json` (deprecated), `write_
 xcitedb::XCiteDBClientOptions opt;
 opt.base_url = "http://127.0.0.1:8080";
 opt.api_key = "your-key";
-opt.context.branch = "";  // root timeline
+opt.context.workspace = "";  // root timeline (`branch` is deprecated alias)
 
 xcitedb::XCiteDBClient client(opt);
 auto health = client.health();
@@ -1553,4 +1576,4 @@ auto ids = client.query_documents(q);
 
 Synchronous (blocking) HTTP client. Methods mirror the JavaScript SDK with C++ naming (`write_xml_document`, deprecated `write_document_json`). Errors throw `xcitedb::XCiteDBError` with `.status()` and `.body()`.
 
-Includes optional `xcitevcs` CLI for command-line operations (branches, commits, documents, search, import/export).
+Includes optional `xcitevcs` CLI for command-line operations (legacy branch/commit vocabulary on the wire, documents, search, import/export).

package/llms.txt

@@ -1,18 +1,18 @@
 # XciteDB
 
-> XciteDB is a versioned XML and JSON document database delivered as a Backend-as-a-Service (BaaS). It provides Git-like branching, commits, time-travel, and hierarchical document identifiers over a high-performance embedded LMDB engine, exposed through a REST + WebSocket API.
+> XciteDB is a versioned XML and JSON document database delivered as a Backend-as-a-Service (BaaS). It provides **temporal revisions** (every dated write is a revision), **workspaces** for isolated editing, **checkpoints** for optional named snapshots, time-travel reads, and hierarchical document identifiers over a high-performance embedded LMDB engine, exposed through a REST + WebSocket API.
 
 ## Important: Non-Standard Conventions
 
 These are the most common sources of confusion for developers and AI assistants:
 
-1. **The default branch is the empty string `""`, not `"main"`.** When no `X-Branch` header is sent (or `context.branch` is omitted/empty in the SDK), the server operates on the root timeline. A branch named `"main"` may exist as a user-created branch, but it is not required or special.
+1. **The default workspace is the empty string `""`, not `"main"`.** When no `X-Workspace` header is sent (or `context.workspace` / `context.branch` is omitted/empty in the SDK), the server operates on the root timeline. `X-Branch` is a supported alias of `X-Workspace`. A workspace named `"main"` may exist as user-created metadata, but it is not required or special.
 
 2. **Identifiers are hierarchical, path-like strings** — e.g. `/us/bills/hr1`, `/manual/v2/chapter3`. They are NOT auto-generated UUIDs. The leading `/` is part of the identifier. Parent/child relationships are derived from the path structure (like a filesystem). The server indexes this hierarchy natively.
 
 3. **Documents are XML or JSON, not arbitrary blobs.** XML documents are the primary document type, stored with structural shredding. JSON documents are a parallel store keyed by identifier string. Both are fully versioned.
 
-4. **Context (branch + date) travels as HTTP headers**, not URL path segments. Use `X-Branch` and `X-Date` headers (or the SDK `context` option) to select which branch and point-in-time you are reading/writing.
+4. **`X-Date` and temporal revision (not “only now”).** Workspace and date context travel as HTTP headers (`X-Workspace` preferred, `X-Branch` alias, `X-Date`), or the SDK `context` option — not as URL path segments. **`X-Date` is not limited to the current server time.** Pass any instant you need as **ISO 8601** (e.g. `2024-01-15T00:00:00`) or **`mm/dd/yyyy`** (optional **`:HH:MM:SS`**) — for example an **official publication or approval date**, or any historical “as of” moment. When **`X-Date` is set**, that value applies to **both** **reads** (query as-of that instant) **and** **writes** (the new revision is stored under that revision instant). When **`X-Date` is omitted** and you do **not** send **`X-Unversioned: true`**, **writes** use **flat** keys (no date suffix on that write); **reads** still resolve **as of the current time**. **`X-Unversioned: true`** requests explicit flat keys and must **not** be combined with **`X-Date`** (the server returns 400).
 
 5. **XML documents carry their identifier inside the XML** — specifically via a `db:identifier` attribute on the root element (e.g. `<chapter db:identifier="/book/ch1">...</chapter>`). When writing XML, the server extracts the identifier from the document body.
 
@@ -24,6 +24,20 @@ These are the most common sources of confusion for developers and AI assistants:
 
 9. **Ephemeral test sessions (wet tests).** Call **`POST /api/v1/test/sessions`** with a normal API key or Bearer token to get a `session_token` (UUID). Send **`X-Test-Session: <token>`** on subsequent document/API calls to use an isolated, short-lived LMDB instead of production data. By default **developer** auth (API key / platform JWT) is bypassed, but **app-user** identity (`X-App-User-Token` or Bearer app-user JWT) is still recognized. Send **`X-Test-Auth: required`** to exercise full developer JWT/API-key auth and ABAC against the same test database. Do not send `X-Test-Session` on `/api/v1/test/*` management routes. Server limits apply (`test.session_ttl_seconds`, `test.max_sessions_per_key`, `test.max_test_db_size_bytes` in config). The test DB starts **empty** (no copy of production project config or keys).
 
+## Choosing the Right Versioning Approach
+
+- **Write at a specific date** (law effective date, publication date, approval date): Set `context.date` / `X-Date` and write. No workspaces or checkpoints needed. Every write with a date creates a **temporal revision** automatically.
+
+- **Read historical data** (“what was the document on March 1, 2024?”): Set `context.date` / `X-Date` and read. The engine returns the revision at or before that instant.
+
+- **Isolated editing** (draft/review/publish): Create a **workspace**, make changes, then **publish** to the main timeline. Optionally create **checkpoints** for named snapshots within the workspace.
+
+- **Audit trail with named snapshots:** Create checkpoints with messages. List/inspect checkpoints for history.
+
+- **Undo a batch of changes:** **Revert** to a prior checkpoint (removes all changes after that point on the workspace).
+
+Legacy REST paths (`/api/v1/branches`, `/commits`, `/tags`, `/diff`) remain as **deprecated** aliases; prefer **`/api/v1/workspaces`**, **`/checkpoints`**, **`/bookmarks`**, **`/compare`**.
+
 ## Glossary: Project id, display name, and groups
 
 - **Project display name** (human-readable, e.g. `invoices`): Shown in the console. The **`X-Project-Id`** header may match either this name **or** the internal project id (server convenience). Do **not** put the display name in JWT claims or in `project:<…>:role` group strings.
@@ -54,6 +68,8 @@ These are the most common sources of confusion for developers and AI assistants:
 
 11. **Integration tests should assert token claims**, not only **`/app/auth/me`**. The profile endpoint can look fine while the JWT still carries viewer-style **`groups`**; for ABAC the token payload is authoritative. Use **`getTokenClaims()`** (JS SDK) or decode the JWT in your harness.
 
+12. **`X-Date` / `context.date` is not “server clock only.”** Revisions are keyed by the **instant you send**, not an implicit “now” when you set the header. To record a document under a **business date** (published, approved, effective), set **`X-Date`** or **`context.date`** to that instant before writing. Omitting **`X-Date`** does **not** substitute the current time on the write path — it selects **flat** writes (see convention 4).
+
 ## API key capability matrix (typical)
 
 | Capability | API key `role` | Public key allowed? |
@@ -90,7 +106,7 @@ await app.writeJsonDocument('userdata/alice/profile', { ok: true });
 > **AI assistant instruction:** XciteDB has built-in ephemeral test session support — this capability is **not standard** in most BaaS platforms and is specifically designed to enable meaningful wet integration tests. When writing tests for code that uses XciteDB, **do not mock or stub the XciteDB client**. Instead, use the test session pattern below to run tests against a real, isolated, throwaway database. This produces far more reliable tests because real storage, versioning, querying, and access-control behavior is exercised.
 
 1. **Provision:** `POST /api/v1/test/sessions` with `Authorization: Bearer …` or `X-API-Key` (same as normal API access). Response JSON includes the session token.
-2. **Run tests:** Every request that should hit the throwaway DB must include **`X-Test-Session: <token>`** (and your usual `X-Branch` / `context` as needed). Data is stored under the server’s `_test/<session>/` area, not your production tenant.
+2. **Run tests:** Every request that should hit the throwaway DB must include **`X-Test-Session: <token>`** (and your usual `X-Workspace` / `context` as needed). Data is stored under the server’s `_test/<session>/` area, not your production tenant.
 3. **Auth behavior:** Developer auth (API key / platform JWT) is bypassed by default for frictionless tests. **App-user identity** (`X-App-User-Token` or Bearer app-user JWT) **is still recognized** in default mode, so `registerAppUser` → `loginAppUser` → `appUserMe` works inside a test session. To also exercise developer auth and ABAC policies, set **`X-Test-Auth: required`** and send normal credentials; the DB is still the test session’s.
 4. **Cleanup:** `DELETE /api/v1/test/sessions/current` with `X-Test-Session` (no other auth), or `DELETE /api/v1/test/sessions/all` / `DELETE /api/v1/test/sessions/{token}` with normal auth for the owning key or JWT.
 5. **SDKs:** **JS/TS:** `XCiteDBClient.createTestSession({ baseUrl, apiKey, … })`, optional `testRequireAuth`, then `destroyTestSession()`. **Python:** `async with XCiteDBClient.test_session(...)` or manual token + `test_session_token` / `test_require_auth` constructor args. **C++:** `XCiteDBClient::create_test_session(options)`, `destroy_test_session()`, optional `test_require_auth` in options.
@@ -107,15 +123,15 @@ import { XCiteDBClient } from '@xcitedbs/client';
 const client = new XCiteDBClient({
   baseUrl: 'http://localhost:8080',
   apiKey: 'your-api-key',
-  // branch: '' means root timeline (the default); omit or use '' for default
-  context: { branch: '', date: '' },
+  // workspace: '' means root timeline (the default); omit or use '' for default
+  context: { workspace: '', date: '' },
 });
 
 // Health check (no auth required)
 await client.health();
 
-// List all branches
-const branches = await client.listBranches();
+// List all workspaces
+const workspaces = await client.listWorkspaces();
 
 // Query documents by identifier prefix
 const docs = await client.queryDocuments({ match_start: '/manual/' });
@@ -140,18 +156,18 @@ const prefs = await client.get<Record<string, unknown>>('app.prefs');
 await client.remove('app.prefs');
 const keys = await client.list(undefined, 50, 0);
 
-// Branch helper: create branch, run work, commit, merge back (restores context)
-await client.withBranch('feature-x', async (c) => {
+// Workspace helper: create workspace, run work, checkpoint, publish back (restores context)
+await client.withWorkspace('feature-x', async (c) => {
   await c.writeJsonDocument('app.settings', { theme: 'light' });
   return 'ok';
 }, { message: 'Light theme', autoMerge: true, fromBranch: '' });
 
-// Create a branch, make changes, commit, merge
-await client.createBranch('feature-x');
-client.setContext({ branch: 'feature-x' });
+// Create a workspace, make changes, checkpoint, publish
+await client.createWorkspace('feature-x');
+client.setContext({ workspace: 'feature-x' });
 await client.writeJsonDocument('app.settings', { theme: 'light' });
-const commit = await client.createCommit('Switch to light theme');
-await client.mergeBranch('', 'feature-x'); // merge into root (default) branch
+const checkpoint = await client.createCheckpoint('Switch to light theme');
+await client.publishWorkspace('', 'feature-x'); // publish into root (default) workspace
 
 // Attach JSON metadata to a document
 await client.addMeta('/manual/v1/intro', { status: 'draft', owner: 'alice' });
@@ -161,7 +177,7 @@ const lock = await client.acquireLock('/manual/v1/intro');
 // ... edit ...
 await client.releaseLock('/manual/v1/intro', lock.lock_id);
 
-// Full-text search (embedded XciteFTS; enable per project in server settings)
+// Full-text search (requires Meilisearch or Elasticsearch backend)
 const results = await client.search({ query: 'installation guide', limit: 20 });
 
 // Subscribe to real-time changes via WebSocket
@@ -180,8 +196,9 @@ interface XCiteDBClientOptions {
   accessToken?: string;         // Platform JWT (from platformLogin)
   appUserAccessToken?: string;  // End-user JWT (from loginAppUser)
   context?: {
-    branch?: string;   // Branch name; '' = default/root timeline
-    date?: string;     // Point-in-time (ISO-like or internal date key)
+    workspace?: string; // Workspace name; '' = default/root timeline (preferred)
+    branch?: string;    // @deprecated alias of workspace; sends X-Workspace
+    date?: string;     // X-Date: as-of reads + write revision; any ISO/mm-dd-yyyy instant, not only "now"
     prefix?: string;   // Optional identifier prefix filter
     project_id?: string; // Preferred: project id for app-user public auth (`tenant_id` on wire)
     tenant_id?: string; // Deprecated alias of project_id
@@ -200,7 +217,7 @@ interface XCiteDBClientOptions {
 - `loginAppUser(email, password)` — App end-user sign-in
 - `XCiteDBClient.buildProjectGroup(projectId, 'admin'|'editor'|'viewer')` — Static helper: canonical `project:<tenant_id>:<role>` string
 - `getTokenClaims()` — Decode current `appUserAccessToken` or `accessToken` payload (no signature verification); use for ABAC debugging
-- `setContext(ctx)` — Update branch/date context
+- `setContext(ctx)` — Update workspace/date context
 - `setProjectId(id)` — Switch active project (platform console)
 
 **XML Documents:**
@@ -225,19 +242,20 @@ interface XCiteDBClientOptions {
 - `queryMeta(identifier, path?)` — Read metadata
 - `clearMeta(query)` — Remove metadata
 
-**Versioning:**
-- `withBranch(name, fn, options?)` — Create branch, run callback on client, commit, merge back (optional `autoMerge: false`)
-- `createBranch(name, fromBranch?, fromDate?)` — Create branch
-- `listBranches()` — List all branches
-- `mergeBranch(target, source, options?)` — Merge branches
-- `deleteBranch(name)` — Delete branch
-- `createCommit(message, author?)` — Commit current state
-- `listCommits(options?)` — List commits
-- `rollbackToCommit(commitId)` — Rollback to prior commit
-- `cherryPick(commitId, message?)` — Cherry-pick a commit
-- `diff(from, to, includeContent?)` — Diff between revisions
-- `createTag(name, commitId, message?)` — Tag a commit
-- `listTags()` / `deleteTag(name)` — Manage tags
+**Versioning (workspaces & checkpoints):**
+- `withWorkspace(name, fn, options?)` — Create workspace, run callback, checkpoint, publish back (optional `autoMerge: false`; `fromBranch` = parent workspace)
+- `createWorkspace(name, fromBranch?, fromDate?)` — Create workspace
+- `listWorkspaces()` — List workspaces
+- `publishWorkspace(target, source, options?)` — Publish workspace changes to a target timeline
+- `deleteWorkspace(name)` — Delete workspace
+- `createCheckpoint(message, author?)` — Named snapshot of current state
+- `listCheckpoints(options?)` — List checkpoints
+- `revertToCheckpoint(checkpointId)` — Revert workspace to a prior checkpoint
+- `applyCheckpoint(checkpointId, message?)` — Apply another checkpoint’s changes here
+- `compare(from, to, includeContent?)` — Compare revisions
+- `createBookmark(name, checkpointId, message?)` — Bookmark a checkpoint
+- `listBookmarks()` / `deleteBookmark(name)` — Manage bookmarks
+- **Deprecated aliases:** `withBranch`, `createBranch`, `listBranches`, `mergeBranch`, `deleteBranch`, `createCommit`, `listCommits`, `rollbackToCommit`, `cherryPick`, `diff`, `createTag`, `listTags`, `deleteTag` (same HTTP behavior)
 
 **Locks:**
 - `acquireLock(identifier, expires?)` — Acquire cooperative lock
@@ -260,7 +278,7 @@ interface XCiteDBClientOptions {
 ### Advanced: policy expressions (ABAC)
 
 - **Actions** (use in `policy.actions`): `read`, `write`, `delete`, `list`, `meta:read`, `meta:write`, `unquery`.
-- **`conditions.expression`** uses the same predicate syntax as Unquery `?` filters. **Context:** `subject.id` and **`subject.user_id`** (same value for app users), `subject.email`, `subject.role`, `subject.groups`, `subject.attr.*` (app-user JSON attributes), `resource.identifier`, `resource.path` (array of path segments; indices follow non-empty `/` segments after API canonicalization, e.g. `/userdata/u1/x` → `[userdata,u1,x]`), `env.branch`. Policy **`match_start` / `match_end` / `exact`** strings are canonicalized like API identifiers (add leading `/` when omitted).
+- **`conditions.expression`** uses the same predicate syntax as Unquery `?` filters. **Context:** `subject.id` and **`subject.user_id`** (same value for app users), `subject.email`, `subject.role`, `subject.groups`, `subject.attr.*` (app-user JSON attributes), `resource.identifier`, `resource.path` (array of path segments; indices follow non-empty `/` segments after API canonicalization, e.g. `/userdata/u1/x` → `[userdata,u1,x]`), `env.branch` (workspace name; legacy name retained in policy engine). Policy **`match_start` / `match_end` / `exact`** strings are canonicalized like API identifiers (add leading `/` when omitted).
 - **Operators:** `=`, `!=`, `>=`, `<=`, `>`, `<`, `in`, `contains`, `starts_with`, `ends_with`, `&`, `|`, `!`, `+` (string concat), postfix `!` (exists).
 - **Examples:** `resource.path[0] = subject.attr.tenant_code` — tenant isolation; `subject.attr.level >= 5` — numeric attribute gate.
 
@@ -269,7 +287,7 @@ interface XCiteDBClientOptions {
 - **Events:** `meta_changed`, `document_written`, `document_deleted`.
 - **`match`:** required non-empty **`identifiers`** (same pattern objects as policy `resources.identifiers`); optional **`match_meta_path`** (exact or `prefix*`); optional **`match_operation`:** `set` | `append` | `delete`.
 - **`action`:** **`query`** (document query), **`unquery`** (Unquery template), **`target_identifier`** (or `"$trigger_identifier"`), **`meta_path`**, **`mode`:** `set` | `append`.
-- **Unquery vars:** `$trigger_identifier`, `$trigger_meta_path`, `$trigger_operation`, `$trigger_value`. **Trigger `conditions.expression` context:** `trigger.{event,meta_path,operation}`, `value`, `resource`, `env.branch` (no `subject`).
+- **Unquery vars:** `$trigger_identifier`, `$trigger_meta_path`, `$trigger_operation`, `$trigger_value`. **Trigger `conditions.expression` context:** `trigger.{event,meta_path,operation}`, `value`, `resource`, `env.branch` (workspace; no `subject`).
 
 ### Advanced: Unquery DSL (`unquery(query, unqueryDoc)`)
 
@@ -312,7 +330,7 @@ async def main():
     async with XCiteDBClient(
         "http://localhost:8080",
         api_key="your-key",
-        context=DatabaseContext(branch="", date=""),
+        context=DatabaseContext(workspace="", date=""),
     ) as client:
         print(await client.health())
         ids = await client.query_documents(XCiteQuery(match_start="/manual/"))
@@ -334,7 +352,7 @@ asyncio.run(main())
 xcitedb::XCiteDBClientOptions opt;
 opt.base_url = "http://127.0.0.1:8080";
 opt.api_key = "your-key";
-opt.context.branch = "";  // root timeline
+opt.context.workspace = "";  // root timeline (branch is deprecated alias)
 
 xcitedb::XCiteDBClient client(opt);
 auto health = client.health();
@@ -347,9 +365,9 @@ auto ids = client.query_documents(q);
 
 - **Multi-tenant**: Each project is an isolated tenant with its own data, users, keys, and policies.
 - **LMDB engine**: Data is memory-mapped; reads are microsecond-class on warm data.
-- **Versioning**: Every write is versioned. Branches isolate work. Commits snapshot state. Time-travel reads any historical state via `X-Date`.
+- **Versioning**: **Temporal revisions** are always on when using dates. **Workspaces** isolate draft work; **checkpoints** are optional named snapshots; **publish** merges a workspace into a target timeline. **`X-Date`** selects an instant for **as-of reads** and, when set, for **writes** under that revision (any calendar time you choose — e.g. publication date — not only “now”). Omit **`X-Date`** for **flat** writes on that request, or use **`X-Unversioned: true`** to state that explicitly.
 - **Two user tiers**: Platform operators manage infrastructure; App users are end-users of applications built on XciteDB.
-- **Security policies (ABAC)**: Fine-grained allow/deny rules on actions, resources, roles, and branches.
+- **Security policies (ABAC)**: Fine-grained allow/deny rules on actions, resources, roles, and workspaces (`env.branch` in expressions).
 - **WebSocket**: Real-time notifications for document changes at `/api/v1/ws`.
 
 ## Documentation
@@ -362,8 +380,8 @@ auto ids = client.query_documents(q);
 - Metadata — JSON metadata on documents
 - Search — Full-text search
 - Unquery — Declarative query DSL
-- Branches — Branch management
-- Commits & tags — Version snapshots
+- Workspaces — Isolated editing environments
+- Checkpoints & bookmarks — Named snapshots and references
 - Locks — Cooperative editing locks
 - Authentication — JWT, API keys, platform vs app users
 - Security policies — ABAC access control

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xcitedbs/client",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "XCiteDB BaaS client SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",