@hiai-gg/docsmint 0.3.0 → 0.3.2

package/dist/frontend/tags-DVXTut0p.js

@@ -0,0 +1,48 @@
+import { t as e } from "./client-B9hzI0W8.js";
+import { a as t, i as n } from "./schemas-DwtKylCJ.js";
+//#region src/lib/api/tags.ts
+var r = n({
+	name: t().trim().min(1, "Name is required").max(50, "Name must be 50 characters or less"),
+	color: t().max(20, "Color must be 20 characters or less").optional()
+}), i = n({
+	name: t().trim().min(1, "Name is required").max(50, "Name must be 50 characters or less").optional(),
+	color: t().max(20, "Color must be 20 characters or less").optional()
+});
+async function a(t) {
+	return e("/api/tags", {}, t);
+}
+function o(t) {
+	return e(`/api/tags/${t}`);
+}
+function s(t, n) {
+	let i = r.parse({
+		name: t,
+		color: n
+	});
+	return e("/api/tags", {
+		method: "POST",
+		body: JSON.stringify(i)
+	});
+}
+function c(t, n) {
+	let r = i.parse(n);
+	return e(`/api/tags/${t}`, {
+		method: "PATCH",
+		body: JSON.stringify(r)
+	});
+}
+function l(t) {
+	return e(`/api/tags/${t}`, { method: "DELETE" });
+}
+function u(r, i) {
+	let a = n({ tagId: t().uuid() }).parse({ tagId: i });
+	return e(`/api/documents/${r}/tags`, {
+		method: "POST",
+		body: JSON.stringify(a)
+	});
+}
+function d(t, n) {
+	return e(`/api/documents/${t}/tags/${n}`, { method: "DELETE" });
+}
+//#endregion
+export { o as a, c, l as i, i as l, s as n, a as o, r, d as s, u as t };

package/dist/frontend/theme.d.ts

@@ -0,0 +1,4 @@
+export type ThemeMode = "light" | "dark" | "system";
+export declare const theme: { readonly value: ThemeMode; readonly isDark: boolean };
+export declare function setTheme(value: ThemeMode): void;
+export declare function toggleTheme(): void;

package/dist/frontend/theme.js

@@ -0,0 +1,8 @@
+import { t as e } from "./theme.svelte-ei0QxXa8.js";
+//#region ../packages/sdk/frontend-entries/theme.ts
+var t = e, n = e.set;
+function r() {
+	n(t.value === "dark" ? "light" : "dark");
+}
+//#endregion
+export { n as setTheme, t as theme, r as toggleTheme };

package/dist/frontend/theme.svelte-ei0QxXa8.js

@@ -0,0 +1,49 @@
+import { H as e, it as t, ot as n } from "./client-C6QQGb0e.js";
+import { browser as r } from "$app/environment";
+//#region src/lib/stores/theme.svelte.ts
+var i = "hiai-docs-theme", a = /* @__PURE__ */ new Set();
+function o() {
+	if (!r) return "system";
+	let e = localStorage.getItem(i);
+	return e === "light" || e === "dark" || e === "system" ? e : "system";
+}
+function s() {
+	return r ? window.matchMedia("(prefers-color-scheme: dark)").matches : !1;
+}
+function c(e) {
+	return e === "dark" ? !0 : e === "light" ? !1 : s();
+}
+function l(e) {
+	if (!r) return;
+	let t = c(e);
+	document.documentElement.classList.toggle("dark", t);
+	let n = document.querySelector("#app-favicon");
+	n && (n.href = t ? "/favicon_white.ico" : "/favicon.ico");
+}
+function u() {
+	for (let e of a) e();
+}
+var d = n("system"), f = n(!1), p = !1;
+function m() {
+	if (!r || p) return;
+	p = !0, t(d, o(), !0), t(f, c(e(d)), !0), l(e(d));
+	let n = window.matchMedia("(prefers-color-scheme: dark)");
+	n.addEventListener("change", () => {
+		e(d) === "system" && (t(f, n.matches, !0), l("system"), u());
+	});
+}
+function h(e) {
+	t(d, e, !0), r && localStorage.setItem(i, e), t(f, c(e), !0), l(e), u();
+}
+var g = {
+	get value() {
+		return e(d);
+	},
+	get isDark() {
+		return e(f);
+	},
+	init: m,
+	set: h
+};
+//#endregion
+export { g as t };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export type { DocsClientConfig } from "./client.js";
+export { DocsApiError, DocsClient, DocsNetworkError, DocsTimeoutError, } from "./client.js";
+export type * from "./types.js";
+export { configureUserDataLifecycle, createUserDataLifecycle, encodeUserDataExportNdjson, exportUserData, purgeUserData, } from "./lifecycle.js";
+export type { AssertPurgeAllowed, ExportUserDataContext, LifecycleHostStep, LifecycleOperationKind, LifecycleOperationStatus, PurgeUserDataContext, PurgeUserDataResult, UserDataExportRecord, UserDataLifecycle, UserDataLifecycleAdapter, } from "./lifecycle.js";
+export { createDocsmintWorkspaceAssertion, verifyDocsmintWorkspaceAssertion, DOCSMINT_WORKSPACE_CONTEXT_HEADER, EXTERNAL_TENANT_CONTEXT_HEADER, } from "./workspace.js";
+export type { DocsmintWorkspaceContext, WorkspaceAssertionOptions } from "./workspace.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { DocsApiError, DocsClient, DocsNetworkError, DocsTimeoutError, } from "./client.js";
+export { configureUserDataLifecycle, createUserDataLifecycle, encodeUserDataExportNdjson, exportUserData, purgeUserData, } from "./lifecycle.js";
+export { createDocsmintWorkspaceAssertion, verifyDocsmintWorkspaceAssertion, DOCSMINT_WORKSPACE_CONTEXT_HEADER, EXTERNAL_TENANT_CONTEXT_HEADER, } from "./workspace.js";

package/dist/lifecycle.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Server-only account-data lifecycle contract.
+ *
+ * `actorUserId` is deliberately both the actor and the subject in 0.3.2. A
+ * trusted actor deleting another account requires a future, explicit
+ * `subjectUserId` contract; callers must not silently overload this field.
+ */
+export type LifecycleOperationKind = "export" | "purge";
+export type LifecycleOperationStatus = "pending" | "running" | "retryable" | "completed" | "rejected";
+export type LifecycleReason = "account_deletion" | "privacy_request";
+export type ExportUserDataContext = Readonly<{
+    actorUserId: string;
+    requestId: string;
+    idempotencyKey: string;
+    reason: LifecycleReason;
+    signal?: AbortSignal;
+}>;
+export type PurgeUserDataContext = Readonly<{
+    actorUserId: string;
+    requestId: string;
+    idempotencyKey: string;
+    reason: LifecycleReason;
+    signal?: AbortSignal;
+}>;
+export type UserDataExportRecord = Readonly<{
+    type: "manifest";
+    schemaVersion: 1;
+    exportId: string;
+    actorUserId: string;
+    generatedAt: string;
+}> | Readonly<{
+    type: "data";
+    domain: string;
+    resourceType: string;
+    resourceId: string | null;
+    workspaceId: string | null;
+    payload: unknown;
+}> | Readonly<{
+    type: "attachment";
+    attachmentId: string;
+    workspaceId: string | null;
+    filename: string;
+    contentType: string;
+    size: number;
+    sha256: string | null;
+}> | Readonly<{
+    type: "complete";
+    recordCount: number;
+    checksum: string;
+}>;
+export type PurgeUserDataResult = Readonly<{
+    status: "completed" | "already_completed";
+    operationId: string;
+    deletedByDomain: Readonly<Record<string, number>>;
+}>;
+export type AssertPurgeAllowed = (ctx: PurgeUserDataContext) => Promise<Readonly<{
+    fenceToken: string;
+}>>;
+export type LifecycleHostStep = Readonly<{
+    id: string;
+    order: number;
+    export?: (ctx: ExportUserDataContext) => AsyncIterable<UserDataExportRecord>;
+    purge?: (ctx: PurgeUserDataContext) => Promise<Readonly<{
+        deletedCount: number;
+    }>>;
+}>;
+export interface UserDataLifecycleAdapter {
+    exportUserData(ctx: ExportUserDataContext): AsyncIterable<UserDataExportRecord>;
+    purgeUserData(ctx: PurgeUserDataContext, gate: Readonly<{
+        fenceToken: string;
+    }>): Promise<PurgeUserDataResult>;
+}
+export interface UserDataLifecycle {
+    exportUserData(ctx: ExportUserDataContext): AsyncIterable<UserDataExportRecord>;
+    purgeUserData(ctx: PurgeUserDataContext): Promise<PurgeUserDataResult>;
+}
+/** Install a server-only implementation during the host application's bootstrap. */
+export declare function configureUserDataLifecycle(lifecycle: UserDataLifecycle): void;
+export declare function exportUserData(ctx: ExportUserDataContext): AsyncIterable<UserDataExportRecord>;
+export declare function purgeUserData(ctx: PurgeUserDataContext): Promise<PurgeUserDataResult>;
+/** Construct a lifecycle facade around a durable host-owned implementation. */
+export declare function createUserDataLifecycle(adapter: UserDataLifecycleAdapter, assertPurgeAllowed: AssertPurgeAllowed): UserDataLifecycle;
+/** Validate and deterministically order registered host steps. */
+export declare function orderLifecycleHostSteps(steps: readonly LifecycleHostStep[]): readonly LifecycleHostStep[];
+/**
+ * Encode the typed stream as canonical NDJSON. The producer is authoritative
+ * for the terminal checksum, while the encoder verifies record sequencing so
+ * a partial or malformed stream is never presented as a valid export.
+ */
+export declare function encodeUserDataExportNdjson(records: AsyncIterable<UserDataExportRecord>): ReadableStream<Uint8Array>;

package/dist/lifecycle.js

@@ -0,0 +1,99 @@
+/**
+ * Server-only account-data lifecycle contract.
+ *
+ * `actorUserId` is deliberately both the actor and the subject in 0.3.2. A
+ * trusted actor deleting another account requires a future, explicit
+ * `subjectUserId` contract; callers must not silently overload this field.
+ */
+let configuredLifecycle;
+/** Install a server-only implementation during the host application's bootstrap. */
+export function configureUserDataLifecycle(lifecycle) {
+    configuredLifecycle = lifecycle;
+}
+function requireLifecycle() {
+    if (!configuredLifecycle) {
+        throw new Error("DocsMint user-data lifecycle has not been configured");
+    }
+    return configuredLifecycle;
+}
+export function exportUserData(ctx) {
+    return requireLifecycle().exportUserData(Object.freeze({ ...ctx }));
+}
+export function purgeUserData(ctx) {
+    return requireLifecycle().purgeUserData(Object.freeze({ ...ctx }));
+}
+/** Construct a lifecycle facade around a durable host-owned implementation. */
+export function createUserDataLifecycle(adapter, assertPurgeAllowed) {
+    return {
+        exportUserData: (ctx) => adapter.exportUserData(Object.freeze({ ...ctx })),
+        async purgeUserData(ctx) {
+            const immutableContext = Object.freeze({ ...ctx });
+            throwIfAborted(immutableContext.signal);
+            const gate = await assertPurgeAllowed(immutableContext);
+            if (!gate.fenceToken)
+                throw new Error("Purge gate returned an empty fence token");
+            throwIfAborted(immutableContext.signal);
+            return adapter.purgeUserData(immutableContext, gate);
+        },
+    };
+}
+/** Validate and deterministically order registered host steps. */
+export function orderLifecycleHostSteps(steps) {
+    const ids = new Set();
+    for (const step of steps) {
+        if (!step.id || ids.has(step.id)) {
+            throw new Error(`Duplicate or empty lifecycle host step ID: ${step.id}`);
+        }
+        ids.add(step.id);
+    }
+    return Object.freeze([...steps].sort((a, b) => a.order - b.order || a.id.localeCompare(b.id)));
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+/**
+ * Encode the typed stream as canonical NDJSON. The producer is authoritative
+ * for the terminal checksum, while the encoder verifies record sequencing so
+ * a partial or malformed stream is never presented as a valid export.
+ */
+export function encodeUserDataExportNdjson(records) {
+    const encoder = new TextEncoder();
+    const iterator = records[Symbol.asyncIterator]();
+    let seenManifest = false;
+    let seenComplete = false;
+    let exhausted = false;
+    return new ReadableStream({
+        async pull(controller) {
+            try {
+                const next = await iterator.next();
+                if (next.done) {
+                    exhausted = true;
+                    if (!seenComplete)
+                        throw new Error("Lifecycle export ended without complete record");
+                    controller.close();
+                    return;
+                }
+                const record = next.value;
+                if (!seenManifest) {
+                    if (record.type !== "manifest")
+                        throw new Error("Lifecycle export must begin with manifest");
+                    seenManifest = true;
+                }
+                else if (seenComplete) {
+                    throw new Error("Lifecycle export emitted a record after complete");
+                }
+                if (record.type === "complete")
+                    seenComplete = true;
+                controller.enqueue(encoder.encode(`${JSON.stringify(record)}\n`));
+            }
+            catch (error) {
+                controller.error(error);
+            }
+        },
+        async cancel(reason) {
+            if (!exhausted)
+                await iterator.return?.(reason);
+        },
+    });
+}

package/{packages/sdk/dist → dist}/types.d.ts

@@ -65,6 +65,11 @@ export interface DocsDocumentListResponse {
     page: number;
     limit: number;
 }
+/** Opaque, scope-bound cursor returned by the bounded document listing API. */
+export interface DocsDocumentCursorPage {
+    items: DocsDocumentListItem[];
+    nextCursor: string | null;
+}
 export interface DocsFolder {
     id: string;
     ownerId: string;

package/dist/workspace.d.ts

@@ -0,0 +1,21 @@
+/** Public, server-only workspace assertion contract. */
+export declare const DOCSMINT_WORKSPACE_CONTEXT_HEADER = "x-docsmint-workspace-context";
+/** @deprecated Compatibility header accepted only during 0.3.x. */
+export declare const EXTERNAL_TENANT_CONTEXT_HEADER = "x-hiai-tenant-context";
+export type DocsmintWorkspaceContext = Readonly<{
+    actorUserId: string;
+    workspaceId: string;
+    actorRole: "owner" | "admin" | "editor" | "viewer";
+    issuedAt: number;
+    expiresAt: number;
+    issuer: string;
+}>;
+export type WorkspaceAssertionOptions = Readonly<{
+    secret: string;
+    issuer: string;
+    nowSeconds?: number;
+    clockSkewSeconds?: number;
+    maxTtlSeconds?: number;
+}>;
+export declare function createDocsmintWorkspaceAssertion(context: DocsmintWorkspaceContext, secret: string): Promise<string>;
+export declare function verifyDocsmintWorkspaceAssertion(assertion: string, options: WorkspaceAssertionOptions): Promise<DocsmintWorkspaceContext>;

package/dist/workspace.js

@@ -0,0 +1,66 @@
+/** Public, server-only workspace assertion contract. */
+export const DOCSMINT_WORKSPACE_CONTEXT_HEADER = "x-docsmint-workspace-context";
+/** @deprecated Compatibility header accepted only during 0.3.x. */
+export const EXTERNAL_TENANT_CONTEXT_HEADER = "x-hiai-tenant-context";
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const MAX_TTL_SECONDS = 300;
+function toBase64Url(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function fromBase64Url(value) {
+    if (!/^[A-Za-z0-9_-]+$/.test(value))
+        throw new Error("Invalid base64url");
+    const padded = value.replaceAll("-", "+").replaceAll("_", "/") + "=".repeat((4 - (value.length % 4)) % 4);
+    const binary = atob(padded);
+    return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+async function sign(payload, secret) {
+    const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    return toBase64Url(new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(payload))));
+}
+function assertContext(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("Invalid workspace assertion payload");
+    const context = value;
+    if (typeof context.actorUserId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(context.actorUserId))
+        throw new Error("Invalid actorUserId");
+    if (typeof context.workspaceId !== "string" || !context.workspaceId.trim() || context.workspaceId.trim() !== context.workspaceId || context.workspaceId.length > 128)
+        throw new Error("Invalid workspaceId");
+    if (!["owner", "admin", "editor", "viewer"].includes(context.actorRole))
+        throw new Error("Invalid actorRole");
+    if (!Number.isFinite(context.issuedAt) || !Number.isFinite(context.expiresAt) || typeof context.issuer !== "string" || !context.issuer)
+        throw new Error("Invalid workspace assertion timestamps or issuer");
+}
+export async function createDocsmintWorkspaceAssertion(context, secret) {
+    assertContext(context);
+    const payload = toBase64Url(encoder.encode(JSON.stringify(context)));
+    return `${payload}.${await sign(payload, secret)}`;
+}
+export async function verifyDocsmintWorkspaceAssertion(assertion, options) {
+    const [payload, signature, ...extra] = assertion.split(".");
+    if (!payload || !signature || extra.length)
+        throw new Error("Invalid workspace assertion format");
+    const key = await crypto.subtle.importKey("raw", encoder.encode(options.secret), { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
+    const valid = await crypto.subtle.verify("HMAC", key, fromBase64Url(signature), encoder.encode(payload));
+    if (!valid)
+        throw new Error("Invalid workspace assertion signature");
+    let context;
+    try {
+        context = JSON.parse(decoder.decode(fromBase64Url(payload)));
+    }
+    catch {
+        throw new Error("Invalid workspace assertion payload");
+    }
+    assertContext(context);
+    if (context.issuer !== options.issuer)
+        throw new Error("Invalid workspace assertion issuer");
+    const now = options.nowSeconds ?? Math.floor(Date.now() / 1000);
+    const skew = options.clockSkewSeconds ?? 5;
+    if (context.issuedAt > now + skew || context.expiresAt <= now - skew || context.expiresAt <= context.issuedAt || context.expiresAt - context.issuedAt > (options.maxTtlSeconds ?? MAX_TTL_SECONDS))
+        throw new Error("Invalid workspace assertion lifetime");
+    return Object.freeze({ ...context });
+}

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@hiai-gg/docsmint",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
+  "browser": {
+    "./dist/lifecycle.js": false,
+    "./dist/workspace.js": false
+  },
   "license": "Apache-2.0",
   "description": "The lightweight, AI-native self-hosted knowledge base — built-in RAG, hybrid semantic search, and a clean REST API for AI agents.",
   "repository": {
@@ -31,36 +35,78 @@
     "outline-alternative",
     "docmost-alternative"
   ],
-  "main": "./packages/sdk/dist/index.js",
-  "types": "./packages/sdk/dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./packages/sdk/dist/index.js",
-      "types": "./packages/sdk/dist/index.d.ts"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
     "./sdk": {
-      "import": "./packages/sdk/dist/index.js",
-      "types": "./packages/sdk/dist/index.d.ts"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./lifecycle": {
+      "browser": "./dist/server-only-browser-entry.js",
+      "import": "./dist/lifecycle.js",
+      "types": "./dist/lifecycle.d.ts"
+    },
+    "./workspace": {
+      "browser": "./dist/server-only-browser-entry.js",
+      "import": "./dist/workspace.js",
+      "types": "./dist/workspace.d.ts"
     },
-    "./frontend": {
-      "import": "./frontend/src/lib/index.ts",
-      "types": "./frontend/src/lib/index.ts"
+    "./frontend/dashboard": {
+      "import": "./dist/frontend/dashboard.js",
+      "types": "./dist/frontend/dashboard.d.ts"
+    },
+    "./frontend/search": {
+      "import": "./dist/frontend/search.js",
+      "types": "./dist/frontend/search.d.ts"
     },
     "./frontend/shared-document": {
-      "import": "./frontend/src/lib/components/editor/shared-document.ts",
-      "types": "./frontend/src/lib/components/editor/shared-document.ts"
+      "import": "./dist/frontend/shared-document.js",
+      "types": "./dist/frontend/shared-document.d.ts"
+    },
+    "./frontend/extension": {
+      "import": "./dist/frontend/extension.js",
+      "types": "./dist/frontend/extension.d.ts"
+    },
+    "./frontend/api/categories": {
+      "import": "./dist/frontend/api/categories.js",
+      "types": "./dist/frontend/api/categories.d.ts"
+    },
+    "./frontend/api/documents": {
+      "import": "./dist/frontend/api/documents.js",
+      "types": "./dist/frontend/api/documents.d.ts"
+    },
+    "./frontend/api/folders": {
+      "import": "./dist/frontend/api/folders.js",
+      "types": "./dist/frontend/api/folders.d.ts"
+    },
+    "./frontend/api/tags": {
+      "import": "./dist/frontend/api/tags.js",
+      "types": "./dist/frontend/api/tags.d.ts"
+    },
+    "./frontend/api/settings": {
+      "import": "./dist/frontend/api/settings.js",
+      "types": "./dist/frontend/api/settings.d.ts"
+    },
+    "./frontend/components/sidebar": {
+      "import": "./dist/frontend/components/sidebar.js",
+      "types": "./dist/frontend/components/sidebar.d.ts"
     },
-    "./frontend/extensions": {
-      "import": "./frontend/src/lib/extensions/types.ts",
-      "types": "./frontend/src/lib/extensions/types.ts"
+    "./frontend/components/settings": {
+      "import": "./dist/frontend/components/settings.js",
+      "types": "./dist/frontend/components/settings.d.ts"
     },
-    "./frontend/hosts": {
-      "import": "./frontend/src/lib/hosts/index.ts",
-      "types": "./frontend/src/lib/hosts/index.ts"
+    "./frontend/theme": {
+      "import": "./dist/frontend/theme.js",
+      "types": "./dist/frontend/theme.d.ts"
     },
-    "./frontend/legacy/doc-tab-registry": {
-      "import": "./frontend/src/lib/stores/doc-tab-registry.svelte.ts",
-      "types": "./frontend/src/lib/stores/doc-tab-registry.svelte.ts"
+    "./frontend/i18n": {
+      "import": "./dist/frontend/i18n.js",
+      "types": "./dist/frontend/i18n.d.ts"
     },
     "./schema": {
       "import": "./packages/db/src/schema.ts",
@@ -98,12 +144,7 @@
     "hiai-docs-mcp": "./packages/mcp-server/src/index.ts"
   },
   "files": [
-    "packages/sdk/dist/index.js",
-    "packages/sdk/dist/index.d.ts",
-    "packages/sdk/dist/client.js",
-    "packages/sdk/dist/client.d.ts",
-    "packages/sdk/dist/types.js",
-    "packages/sdk/dist/types.d.ts",
+    "dist",
     "packages/db/src/index.ts",
     "packages/db/src/client.ts",
     "packages/db/src/schema.ts",
@@ -120,14 +161,6 @@
     "backend/src/lib/redis-factory.ts",
     "backend/src/lib/storage-factory.ts",
     "backend/src/lib/logger.ts",
-    "frontend/src/lib/index.ts",
-    "frontend/src/lib/extensions/context.ts",
-    "frontend/src/lib/extensions/doc-tabs.ts",
-    "frontend/src/lib/extensions/resolve.ts",
-    "frontend/src/lib/extensions/types.ts",
-    "frontend/src/lib/hosts",
-    "frontend/src/lib/stores/doc-tab-registry.svelte.ts",
-    "frontend/src/lib/components/editor/shared-document.ts",
     "README.md",
     "LICENSE"
   ],
@@ -156,6 +189,7 @@
     "ioredis": "^5.4.0",
     "@aws-sdk/client-s3": "^3.0.0",
     "pino": "^10.0.0",
+    "@sveltejs/kit": "^2.68.0",
     "svelte": "^5.56.4"
   },
   "peerDependenciesMeta": {
@@ -175,4 +209,4 @@
       "optional": true
     }
   }
-}
+}

package/packages/cli/src/index.ts

@@ -24,7 +24,7 @@ import { registerSearch } from "./commands/search.js";
 import { registerSnapshot } from "./commands/snapshot.js";
 import { registerUpdate } from "./commands/update.js";
 
-const VERSION = "0.3.0";
+const VERSION = "0.3.2";
 
 const program = new Command();
 program

package/packages/db/src/schema.ts

@@ -56,6 +56,17 @@ export const pipelineStatusEnum = pgEnum("pipeline_status", [
   "skipped",
   "cancelled",
 ]);
+export const lifecycleOperationKindEnum = pgEnum("lifecycle_operation_kind", [
+  "export",
+  "purge",
+]);
+export const lifecycleOperationStatusEnum = pgEnum("lifecycle_operation_status", [
+  "pending",
+  "running",
+  "retryable",
+  "completed",
+  "rejected",
+]);
 
 // ============================================
 // users — managed by Better Auth
@@ -680,6 +691,36 @@ export const auditLog = pgTable(
   ]
 );
 
+// Durable, server-only lifecycle saga state. This table records only safe
+// metadata and counts; raw fence tokens, documents, secrets, and provider
+// errors are intentionally excluded from the schema.
+export const lifecycleOperations = pgTable(
+  "lifecycle_operations",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    actorUserId: uuid("actor_user_id").notNull().references(() => users.id, { onDelete: "restrict" }),
+    idempotencyKey: text("idempotency_key").notNull(),
+    operationKind: lifecycleOperationKindEnum("operation_kind").notNull(),
+    status: lifecycleOperationStatusEnum("status").notNull().default("pending"),
+    leaseOwner: text("lease_owner"),
+    leaseExpiresAt: timestamp("lease_expires_at"),
+    fenceTokenHash: text("fence_token_hash"),
+    completedSteps: jsonb("completed_steps").notNull().default("[]"),
+    terminalResult: jsonb("terminal_result"),
+    safeErrorCode: text("safe_error_code"),
+    attemptCount: integer("attempt_count").notNull().default(0),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+    completedAt: timestamp("completed_at"),
+  },
+  (table) => [
+    uniqueIndex("lifecycle_operations_actor_idempotency_idx").on(table.actorUserId, table.idempotencyKey),
+    index("lifecycle_operations_status_lease_idx").on(table.status, table.leaseExpiresAt),
+    index("lifecycle_operations_actor_idx").on(table.actorUserId),
+    index("lifecycle_operations_retryable_idx").on(table.status).where(sql`${table.status} = 'retryable'`),
+  ],
+);
+
 export const versionRelations = relations(versions, ({ one }) => ({
   document: one(documents, {
     fields: [versions.documentId],

package/packages/mcp-server/src/index.ts

@@ -35,7 +35,7 @@ interface McpToolResult {
 
 const server = new McpServer({
 	name: "hiai-docs",
-	version: "0.3.0",
+	version: "0.3.2",
 });
 
 /**