@hiai-gg/docsmint 0.3.2 → 0.3.3

package/backend/src/lib/lifecycle-service.ts

@@ -0,0 +1,574 @@
+import {
+	attachments,
+	auditLog,
+	db,
+	documentEmbeddings,
+	documents,
+	lifecycleOperations,
+	shareLinks,
+	versions,
+} from "@hiai-docs/db";
+import type {
+	AssertPurgeAllowed,
+	ExportUserDataContext,
+	LifecycleHostStep,
+	PurgeUserDataContext,
+	PurgeUserDataResult,
+	UserDataExportRecord,
+} from "@hiai-docs/sdk";
+import { and, eq, inArray, lt, or, sql } from "drizzle-orm";
+
+const LEASE_MS = 60_000;
+const SAFE_ERROR_CODES = new Set([
+	"aborted",
+	"fence_rejected",
+	"lease_lost",
+	"object_storage_failed",
+	"queue_failed",
+	"redis_failed",
+	"graph_failed",
+	"host_step_failed",
+	"persistence_failed",
+]);
+
+type PersistentOperation = typeof lifecycleOperations.$inferSelect;
+
+export type LifecycleRuntimeAdapters = Readonly<{
+	/** Checks the host-owned fence immediately before the first mutation. */
+	verifyPurgeFence: (
+		ctx: PurgeUserDataContext,
+		fenceToken: string,
+	) => Promise<void>;
+	deleteObjects: (
+		keys: readonly string[],
+		signal?: AbortSignal,
+	) => Promise<number>;
+	cancelAccountJobs: (
+		actorUserId: string,
+		signal?: AbortSignal,
+	) => Promise<number>;
+	clearAccountRedisState: (
+		actorUserId: string,
+		signal?: AbortSignal,
+	) => Promise<number>;
+	removeCollaborationState: (
+		actorUserId: string,
+		signal?: AbortSignal,
+	) => Promise<number>;
+	removeGraphState: (
+		documentIds: readonly string[],
+		signal?: AbortSignal,
+	) => Promise<number>;
+}>;
+
+export type PersistentLifecycleService = Readonly<{
+	exportUserData(
+		ctx: ExportUserDataContext,
+	): AsyncIterable<UserDataExportRecord>;
+	purgeUserData(
+		ctx: PurgeUserDataContext,
+		gate: Readonly<{ fenceToken: string }>,
+	): Promise<PurgeUserDataResult>;
+}>;
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+	if (signal?.aborted)
+		throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+
+function safeErrorCode(error: unknown): string {
+	if (error instanceof DOMException && error.name === "AbortError")
+		return "aborted";
+	if (error instanceof Error && SAFE_ERROR_CODES.has(error.message))
+		return error.message;
+	return "persistence_failed";
+}
+
+function tokenHash(token: string): string {
+	return new Bun.CryptoHasher("sha256").update(token).digest("hex");
+}
+
+function checksumLine(
+	hash: Bun.CryptoHasher,
+	record: UserDataExportRecord,
+): void {
+	hash.update(`${JSON.stringify(record)}\n`, "utf8");
+}
+
+function counts(value: unknown): Record<string, number> {
+	return typeof value === "object" && value !== null
+		? (value as Record<string, number>)
+		: {};
+}
+
+function operationCounts(
+	operation: PersistentOperation,
+): Record<string, number> {
+	const result = operation.terminalResult as {
+		deletedByDomain?: unknown;
+	} | null;
+	return counts(result?.deletedByDomain);
+}
+
+/**
+ * Durable OSS-owned lifecycle saga. It does not know workspace membership or
+ * billing policy: the caller supplies a host fence and optional host steps.
+ */
+export function createPersistentLifecycleService(
+	runtime: LifecycleRuntimeAdapters,
+	hostSteps: readonly LifecycleHostStep[] = [],
+): PersistentLifecycleService {
+	const orderedSteps = [...hostSteps].sort(
+		(a, b) => a.order - b.order || a.id.localeCompare(b.id),
+	);
+	if (
+		new Set(orderedSteps.map((step) => step.id)).size !== orderedSteps.length
+	) {
+		throw new Error("Lifecycle host step IDs must be globally unique");
+	}
+
+	async function getOrCreateOperation(
+		ctx: PurgeUserDataContext,
+	): Promise<PersistentOperation> {
+		await db
+			.insert(lifecycleOperations)
+			.values({
+				actorUserId: ctx.actorUserId,
+				idempotencyKey: ctx.idempotencyKey,
+				operationKind: "purge",
+				status: "pending",
+			})
+			.onConflictDoNothing();
+		const operation = await db.query.lifecycleOperations.findFirst({
+			where: and(
+				eq(lifecycleOperations.actorUserId, ctx.actorUserId),
+				eq(lifecycleOperations.idempotencyKey, ctx.idempotencyKey),
+			),
+		});
+		if (!operation) throw new Error("persistence_failed");
+		if (operation.operationKind !== "purge")
+			throw new Error("persistence_failed");
+		return operation;
+	}
+
+	async function acquireLease(
+		operation: PersistentOperation,
+		owner: string,
+	): Promise<boolean> {
+		const now = new Date();
+		const expiry = new Date(now.getTime() + LEASE_MS);
+		const updated = await db
+			.update(lifecycleOperations)
+			.set({
+				status: "running",
+				leaseOwner: owner,
+				leaseExpiresAt: expiry,
+				attemptCount: sql`${lifecycleOperations.attemptCount} + 1`,
+				updatedAt: now,
+			})
+			.where(
+				and(
+					eq(lifecycleOperations.id, operation.id),
+					or(
+						eq(lifecycleOperations.status, "pending"),
+						eq(lifecycleOperations.status, "retryable"),
+						and(
+							eq(lifecycleOperations.status, "running"),
+							lt(lifecycleOperations.leaseExpiresAt, now),
+						),
+					),
+				),
+			)
+			.returning({ id: lifecycleOperations.id });
+		return updated.length === 1;
+	}
+
+	async function persistStep(
+		operationId: string,
+		leaseOwner: string,
+		step: string,
+		deletedByDomain: Record<string, number>,
+	): Promise<void> {
+		const current = await db.query.lifecycleOperations.findFirst({
+			where: and(
+				eq(lifecycleOperations.id, operationId),
+				eq(lifecycleOperations.leaseOwner, leaseOwner),
+			),
+		});
+		if (!current) throw new Error("lease_lost");
+		if (
+			current.status !== "running" ||
+			(current.leaseExpiresAt && current.leaseExpiresAt < new Date())
+		) {
+			throw new Error("lease_lost");
+		}
+		const completed = Array.isArray(current.completedSteps)
+			? current.completedSteps.filter(
+					(value): value is string => typeof value === "string",
+				)
+			: [];
+		if (!completed.includes(step)) completed.push(step);
+		await db
+			.update(lifecycleOperations)
+			.set({
+				completedSteps: completed,
+				terminalResult: { deletedByDomain },
+				updatedAt: new Date(),
+			})
+			.where(
+				and(
+					eq(lifecycleOperations.id, operationId),
+					eq(lifecycleOperations.leaseOwner, leaseOwner),
+				),
+			);
+	}
+
+	async function runStep(
+		operation: PersistentOperation,
+		leaseOwner: string,
+		step: string,
+		deletedByDomain: Record<string, number>,
+		action: () => Promise<number>,
+	): Promise<void> {
+		const completed = Array.isArray(operation.completedSteps)
+			? operation.completedSteps
+			: [];
+		if (completed.includes(step)) return;
+		const count = await action();
+		deletedByDomain[step] = count;
+		await persistStep(operation.id, leaseOwner, step, deletedByDomain);
+		operation.completedSteps = [...completed, step];
+	}
+
+	return {
+		async *exportUserData(ctx) {
+			throwIfAborted(ctx.signal);
+			const exportId = crypto.randomUUID();
+			const hash = new Bun.CryptoHasher("sha256");
+			let recordCount = 0;
+			const manifest: UserDataExportRecord = {
+				type: "manifest",
+				schemaVersion: 1,
+				exportId,
+				actorUserId: ctx.actorUserId,
+				generatedAt: new Date().toISOString(),
+			};
+			checksumLine(hash, manifest);
+			recordCount += 1;
+			yield manifest;
+			const ownedDocuments = await db
+				.select()
+				.from(documents)
+				.where(eq(documents.ownerId, ctx.actorUserId));
+			for (const document of ownedDocuments) {
+				throwIfAborted(ctx.signal);
+				const record: UserDataExportRecord = {
+					type: "data",
+					domain: "documents",
+					resourceType: "document",
+					resourceId: document.id,
+					workspaceId: document.workspaceId,
+					payload: {
+						title: document.title,
+						content: document.content,
+						contentJson: document.contentJson,
+						metadata: document.metadata,
+						visibility: document.visibility,
+						createdAt: document.createdAt,
+						updatedAt: document.updatedAt,
+					},
+				};
+				checksumLine(hash, record);
+				recordCount += 1;
+				yield record;
+			}
+			const ownedAttachments = await db
+				.select({
+					id: attachments.id,
+					workspaceId: attachments.workspaceId,
+					filename: attachments.filename,
+					mimeType: attachments.mimeType,
+					size: attachments.size,
+				})
+				.from(attachments)
+				.innerJoin(documents, eq(attachments.documentId, documents.id))
+				.where(eq(documents.ownerId, ctx.actorUserId));
+			for (const attachment of ownedAttachments) {
+				throwIfAborted(ctx.signal);
+				const record: UserDataExportRecord = {
+					type: "attachment",
+					attachmentId: attachment.id,
+					workspaceId: attachment.workspaceId,
+					filename: attachment.filename,
+					contentType: attachment.mimeType,
+					size: attachment.size,
+					sha256: null,
+				};
+				checksumLine(hash, record);
+				recordCount += 1;
+				yield record;
+			}
+			for (const step of orderedSteps) {
+				if (!step.export) continue;
+				for await (const record of step.export(ctx)) {
+					throwIfAborted(ctx.signal);
+					if (record.type === "manifest" || record.type === "complete")
+						throw new Error("Host export step emitted a reserved record type");
+					checksumLine(hash, record);
+					recordCount += 1;
+					yield record;
+				}
+			}
+			yield { type: "complete", recordCount, checksum: hash.digest("hex") };
+		},
+
+		async purgeUserData(ctx, gate) {
+			throwIfAborted(ctx.signal);
+			let operation = await getOrCreateOperation(ctx);
+			if (operation.status === "completed") {
+				return {
+					status: "already_completed",
+					operationId: operation.id,
+					deletedByDomain: operationCounts(operation),
+				};
+			}
+			const leaseOwner = crypto.randomUUID();
+			if (!(await acquireLease(operation, leaseOwner)))
+				throw new Error("lease_lost");
+			operation =
+				(await db.query.lifecycleOperations.findFirst({
+					where: eq(lifecycleOperations.id, operation.id),
+				})) ?? operation;
+			const deletedByDomain = operationCounts(operation);
+			try {
+				throwIfAborted(ctx.signal);
+				await db
+					.update(lifecycleOperations)
+					.set({
+						fenceTokenHash: tokenHash(gate.fenceToken),
+						updatedAt: new Date(),
+					})
+					.where(
+						and(
+							eq(lifecycleOperations.id, operation.id),
+							eq(lifecycleOperations.leaseOwner, leaseOwner),
+						),
+					);
+				await runtime.verifyPurgeFence(ctx, gate.fenceToken);
+
+				await runStep(
+					operation,
+					leaseOwner,
+					"cancel_account_jobs",
+					deletedByDomain,
+					() => runtime.cancelAccountJobs(ctx.actorUserId, ctx.signal),
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_collaboration_state",
+					deletedByDomain,
+					() => runtime.removeCollaborationState(ctx.actorUserId, ctx.signal),
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_subject_created_shares",
+					deletedByDomain,
+					async () =>
+						(
+							await db
+								.delete(shareLinks)
+								.where(eq(shareLinks.createdBy, ctx.actorUserId))
+								.returning({ id: shareLinks.id })
+						).length,
+				);
+				const owned = await db
+					.select({ id: documents.id })
+					.from(documents)
+					.where(eq(documents.ownerId, ctx.actorUserId));
+				const documentIds = owned.map((row) => row.id);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_document_versions",
+					deletedByDomain,
+					async () =>
+						documentIds.length
+							? (
+									await db
+										.delete(versions)
+										.where(inArray(versions.documentId, documentIds))
+										.returning({ id: versions.id })
+								).length
+							: 0,
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_chunks_and_embeddings",
+					deletedByDomain,
+					async () =>
+						documentIds.length
+							? (
+									await db
+										.delete(documentEmbeddings)
+										.where(inArray(documentEmbeddings.documentId, documentIds))
+										.returning({ id: documentEmbeddings.id })
+								).length
+							: 0,
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_graph_state",
+					deletedByDomain,
+					() => runtime.removeGraphState(documentIds, ctx.signal),
+				);
+				const objectRows = documentIds.length
+					? await db
+							.select({
+								id: attachments.id,
+								storageKey: attachments.storageKey,
+							})
+							.from(attachments)
+							.where(inArray(attachments.documentId, documentIds))
+					: [];
+				await runStep(
+					operation,
+					leaseOwner,
+					"delete_attachment_objects",
+					deletedByDomain,
+					() =>
+						runtime.deleteObjects(
+							objectRows.map((row) => row.storageKey),
+							ctx.signal,
+						),
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_attachment_rows",
+					deletedByDomain,
+					async () =>
+						objectRows.length
+							? (
+									await db
+										.delete(attachments)
+										.where(
+											inArray(
+												attachments.id,
+												objectRows.map((row) => row.id),
+											),
+										)
+										.returning({ id: attachments.id })
+								).length
+							: 0,
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"remove_subject_documents",
+					deletedByDomain,
+					async () =>
+						(
+							await db
+								.delete(documents)
+								.where(eq(documents.ownerId, ctx.actorUserId))
+								.returning({ id: documents.id })
+						).length,
+				);
+				await runStep(
+					operation,
+					leaseOwner,
+					"clear_redis_state",
+					deletedByDomain,
+					() => runtime.clearAccountRedisState(ctx.actorUserId, ctx.signal),
+				);
+				for (const step of orderedSteps) {
+					if (!step.purge) continue;
+					await runStep(
+						operation,
+						leaseOwner,
+						`host:${step.id}`,
+						deletedByDomain,
+						async () => (await step.purge?.(ctx))?.deletedCount ?? 0,
+					);
+				}
+				await runStep(
+					operation,
+					leaseOwner,
+					"write_deletion_audit",
+					deletedByDomain,
+					async () => {
+						await db.insert(auditLog).values({
+							actorId: ctx.actorUserId,
+							action: "account_data_purged",
+							resourceType: "lifecycle_operation",
+							details: {
+								operationId: operation.id,
+								outcome: "completed",
+								deletedByDomain,
+							},
+						});
+						return 1;
+					},
+				);
+				await db
+					.update(lifecycleOperations)
+					.set({
+						status: "completed",
+						terminalResult: { deletedByDomain },
+						completedAt: new Date(),
+						leaseOwner: null,
+						leaseExpiresAt: null,
+						updatedAt: new Date(),
+					})
+					.where(
+						and(
+							eq(lifecycleOperations.id, operation.id),
+							eq(lifecycleOperations.leaseOwner, leaseOwner),
+						),
+					);
+				return {
+					status: "completed",
+					operationId: operation.id,
+					deletedByDomain,
+				};
+			} catch (error) {
+				const code = safeErrorCode(error);
+				await db
+					.update(lifecycleOperations)
+					.set({
+						status: code === "fence_rejected" ? "rejected" : "retryable",
+						safeErrorCode: code,
+						leaseOwner: null,
+						leaseExpiresAt: null,
+						completedAt: code === "fence_rejected" ? new Date() : null,
+						updatedAt: new Date(),
+					})
+					.where(
+						and(
+							eq(lifecycleOperations.id, operation.id),
+							eq(lifecycleOperations.leaseOwner, leaseOwner),
+						),
+					);
+				throw error;
+			}
+		},
+	};
+}
+
+/** Builds the public facade without allowing the OSS service to own membership policy. */
+export function bindPersistentLifecycle(
+	service: PersistentLifecycleService,
+	assertPurgeAllowed: AssertPurgeAllowed,
+) {
+	return {
+		exportUserData: service.exportUserData,
+		async purgeUserData(ctx: PurgeUserDataContext) {
+			const gate = await assertPurgeAllowed(ctx);
+			return service.purgeUserData(ctx, gate);
+		},
+	};
+}

package/dist/frontend/api/categories.d.ts

@@ -1,10 +1,14 @@
 
-export type CategoryDto = Readonly<Record<string, unknown>>;
-export declare const createCategoryInputSchema: unknown;
-export declare const updateCategoryInputSchema: unknown;
-export declare function listCategories(...args: readonly unknown[]): Promise<readonly CategoryDto[]>;
-export declare function createCategory(...args: readonly unknown[]): Promise<CategoryDto>;
-export declare function updateCategory(...args: readonly unknown[]): Promise<CategoryDto>;
-export declare function deleteCategory(...args: readonly unknown[]): Promise<unknown>;
-export declare function setDocumentCategory(...args: readonly unknown[]): Promise<unknown>;
-export declare function setFolderCategory(...args: readonly unknown[]): Promise<unknown>;
+import type { z } from "zod";
+export interface CategoryDto { id: string; name: string; order: number; apiMode?: "unavailable" | "global" | "general" | "category" | null; apiPermissionRead?: boolean | null; apiPermissionEdit?: boolean | null; apiPermissionWrite?: boolean | null; createdAt: string; updatedAt: string; documentCount?: number; folderCount?: number; }
+export type Category = CategoryDto;
+export interface CreateCategoryInput { name: string; apiMode?: "unavailable" | "global" | "general" | "category"; apiPermissionRead?: boolean; apiPermissionEdit?: boolean; apiPermissionWrite?: boolean; }
+export interface UpdateCategoryInput { name?: string; order?: number; apiMode?: "unavailable" | "global" | "general" | "category"; apiPermissionRead?: boolean; apiPermissionEdit?: boolean; apiPermissionWrite?: boolean; }
+export declare const createCategoryInputSchema: z.ZodType<CreateCategoryInput>;
+export declare const updateCategoryInputSchema: z.ZodType<UpdateCategoryInput>;
+export declare function listCategories(fetcher?: typeof fetch): Promise<CategoryDto[]>;
+export declare function createCategory(inputOrName: string | CreateCategoryInput): Promise<CategoryDto>;
+export declare function updateCategory(id: string, data: UpdateCategoryInput): Promise<CategoryDto>;
+export declare function deleteCategory(id: string): Promise<void>;
+export declare function setDocumentCategory(documentId: string, categoryId: string | null): Promise<void>;
+export declare function setFolderCategory(folderId: string, categoryId: string | null): Promise<void>;

package/dist/frontend/api/documents.d.ts

@@ -1,10 +1,16 @@
 
-export type DocumentDto = Readonly<Record<string, unknown>>;
-export declare function listDocuments(...args: readonly unknown[]): Promise<readonly DocumentDto[]>;
-export declare function getDocument(...args: readonly unknown[]): Promise<DocumentDto>;
-export declare function createDocument(...args: readonly unknown[]): Promise<DocumentDto>;
-export declare function updateDocument(...args: readonly unknown[]): Promise<DocumentDto>;
-export declare function deleteDocument(...args: readonly unknown[]): Promise<unknown>;
-export declare function importDocument(...args: readonly unknown[]): Promise<DocumentDto>;
-export declare function importDocuments(...args: readonly unknown[]): Promise<readonly DocumentDto[]>;
+export interface DocumentTagDto { id: string; name: string; color: string; }
+export interface DocumentDto { id: string; title: string; content: string; contentJson?: unknown; folderId?: string | null; folderName?: string; categoryId?: string | null; tags?: DocumentTagDto[]; excerpt?: string; createdAt: string; updatedAt: string; }
+export type Document = DocumentDto;
+export interface DocumentListResponse { items: DocumentDto[]; total: number; page: number; limit: number; }
+export interface UpdateDocumentInput { title?: string; content?: string; folderId?: string | null; categoryId?: string | null; contentJson?: unknown; expectedUpdatedAt?: string; }
+export interface ImportResult { filename: string; status: "ok" | "error"; document?: DocumentDto; error?: string; }
+export interface ImportResponse { items: ImportResult[]; imported: number; failed: number; }
+export declare function listDocuments(params?: { folderId?: string; tag?: string; page?: number; limit?: number }, fetcher?: typeof fetch): Promise<DocumentListResponse>;
+export declare function getDocument(id: string, fetcher?: typeof fetch): Promise<DocumentDto>;
+export declare function createDocument(data: { title: string; content?: string; folderId?: string; categoryId?: string }, fetcher?: typeof fetch): Promise<DocumentDto>;
+export declare function updateDocument(id: string, data: UpdateDocumentInput): Promise<DocumentDto>;
+export declare function deleteDocument(id: string): Promise<void>;
+export declare function importDocument(file: File, folderId?: string): Promise<DocumentDto>;
+export declare function importDocuments(files: File[], folderId?: string): Promise<ImportResponse>;
 export declare function clearDocumentsCache(...args: readonly unknown[]): void;

package/dist/frontend/api/folders.d.ts

@@ -1,10 +1,14 @@
 
-export type FolderDto = Readonly<Record<string, unknown>>;
-export declare function listFolders(...args: readonly unknown[]): Promise<readonly FolderDto[]>;
-export declare function getFolder(...args: readonly unknown[]): Promise<FolderDto>;
-export declare function getFolderPath(...args: readonly unknown[]): Promise<readonly FolderDto[]>;
-export declare function createFolder(...args: readonly unknown[]): Promise<FolderDto>;
-export declare function updateFolder(...args: readonly unknown[]): Promise<FolderDto>;
-export declare function deleteFolder(...args: readonly unknown[]): Promise<unknown>;
-export declare function duplicateDocument(...args: readonly unknown[]): Promise<unknown>;
-export declare function deleteDocument(...args: readonly unknown[]): Promise<unknown>;
+export interface FolderDocumentDto { id: string; title: string; content?: string; folderId: string | null; folderName: string; categoryId?: string | null; tags: string[]; createdAt: string; updatedAt: string; excerpt: string; }
+export interface FolderDto { id: string; name: string; parentId: string | null; categoryId?: string | null; order: number; documentCount: number; subfolderCount: number; children: FolderDto[]; documents: FolderDocumentDto[]; createdAt: string; updatedAt: string; }
+export type Folder = FolderDto;
+export interface CreateFolderData { name: string; parentId?: string | null; categoryId?: string | null; }
+export interface UpdateFolderData { name?: string; parentId?: string | null; categoryId?: string | null; order?: number; }
+export declare function listFolders(parentId?: string | null, all?: boolean, fetcher?: typeof fetch): Promise<FolderDto[]>;
+export declare function getFolder(id: string, fetcher?: typeof fetch): Promise<FolderDto>;
+export declare function getFolderPath(folderId: string, fetcher?: typeof fetch): Promise<Array<{ id: string; name: string }>>;
+export declare function createFolder(data: CreateFolderData): Promise<FolderDto>;
+export declare function updateFolder(id: string, data: UpdateFolderData): Promise<FolderDto>;
+export declare function deleteFolder(id: string): Promise<void>;
+export declare function duplicateDocument(documentId: string): Promise<FolderDocumentDto>;
+export declare function deleteDocument(documentId: string): Promise<void>;

package/dist/frontend/api/settings.d.ts

@@ -1,8 +1,10 @@
 
-export type ProfileDto = Readonly<Record<string, unknown>>;
-export type EmbeddingConfigDto = Readonly<Record<string, unknown>>;
-export declare function getProfile(...args: readonly unknown[]): Promise<ProfileDto>;
-export declare function updateProfile(...args: readonly unknown[]): Promise<ProfileDto>;
-export declare function getEmbeddingConfig(...args: readonly unknown[]): Promise<EmbeddingConfigDto>;
-export declare function updateEmbeddingConfig(...args: readonly unknown[]): Promise<EmbeddingConfigDto>;
-export declare function deleteAccount(...args: readonly unknown[]): Promise<unknown>;
+export interface ProfileDto { id: string; name: string; email: string; avatar: string | null; }
+export type UserProfile = ProfileDto;
+export interface EmbeddingConfigDto { baseUrl: string; apiKey: string; model: string; fallbackBaseUrl: string | null; fallbackApiKey: string | null; fallbackModel: string | null; }
+export type EmbeddingConfig = EmbeddingConfigDto;
+export declare function getProfile(): Promise<ProfileDto>;
+export declare function updateProfile(data: { name?: string }): Promise<ProfileDto>;
+export declare function getEmbeddingConfig(): EmbeddingConfigDto;
+export declare function updateEmbeddingConfig(data: Partial<EmbeddingConfigDto>): EmbeddingConfigDto;
+export declare function deleteAccount(): Promise<void>;

package/dist/frontend/api/tags.d.ts

@@ -1,11 +1,15 @@
 
-export type TagDto = Readonly<Record<string, unknown>>;
-export declare const createTagInputSchema: unknown;
-export declare const updateTagInputSchema: unknown;
-export declare function listTags(...args: readonly unknown[]): Promise<readonly TagDto[]>;
-export declare function getTag(...args: readonly unknown[]): Promise<TagDto>;
-export declare function createTag(...args: readonly unknown[]): Promise<TagDto>;
-export declare function updateTag(...args: readonly unknown[]): Promise<TagDto>;
-export declare function deleteTag(...args: readonly unknown[]): Promise<unknown>;
-export declare function addTagToDocument(...args: readonly unknown[]): Promise<unknown>;
-export declare function removeTagFromDocument(...args: readonly unknown[]): Promise<unknown>;
+import type { z } from "zod";
+export interface TagDto { id: string; name: string; color: string | null; createdAt: string; documentCount?: number; }
+export type Tag = TagDto;
+export interface CreateTagInput { name: string; color?: string; }
+export interface UpdateTagInput { name?: string; color?: string; }
+export declare const createTagInputSchema: z.ZodType<CreateTagInput>;
+export declare const updateTagInputSchema: z.ZodType<UpdateTagInput>;
+export declare function listTags(fetcher?: typeof fetch): Promise<TagDto[]>;
+export declare function getTag(id: string): Promise<TagDto>;
+export declare function createTag(name: string, color?: string): Promise<TagDto>;
+export declare function updateTag(id: string, data: UpdateTagInput): Promise<TagDto>;
+export declare function deleteTag(id: string): Promise<void>;
+export declare function addTagToDocument(documentId: string, tagId: string): Promise<void>;
+export declare function removeTagFromDocument(documentId: string, tagId: string): Promise<void>;

package/dist/frontend/extension.d.ts

@@ -1,2 +1,35 @@
-import type { Component } from "svelte";
-export declare const DocsmintExtensionProvider: Component;
+import type { Component, ComponentType, Snippet, SvelteComponent } from "svelte";
+export interface ExtensionVisibilityContext {
+  userId?: string;
+  pathname?: string;
+  capabilities?: Readonly<Record<string, boolean>>;
+  permissions?: Readonly<Record<string, boolean>>;
+}
+export type ExtensionVisibility = (context: ExtensionVisibilityContext) => boolean;
+export type ExtensionIcon = ComponentType<SvelteComponent>;
+export interface DocTabPanelProps { documentId: string; content: string; contentJson: object | undefined; }
+export interface DocTabDefinition { id: string; label: string; component: Component<DocTabPanelProps>; order?: number; icon?: ExtensionIcon; disabled?: boolean; }
+export interface NavigationExtension { id: string; label: string; href?: string; icon?: ExtensionIcon; order?: number; badge?: string | number; disabled?: boolean; visible?: ExtensionVisibility; }
+export interface DashboardWidgetProps { userId?: string; }
+export interface DashboardWidgetExtension { id: string; title?: string; component: Component<DashboardWidgetProps>; order?: number; colSpan?: 1 | 2 | 3 | 4 | 6 | 12; visible?: ExtensionVisibility; }
+export interface SearchWidgetProps { query: string; loading: boolean; total?: number; }
+export interface SearchWidgetExtension { id: string; title?: string; component: Component<SearchWidgetProps>; order?: number; visible?: ExtensionVisibility; }
+export interface EditorActionContext { documentId: string; content: string; contentJson: object | undefined; selection?: unknown; commands?: Readonly<Record<string, (...args: unknown[]) => unknown>>; }
+export type ExtensionAction = (context: EditorActionContext) => void | Promise<void>;
+export interface EditorActionExtension { id: string; label: string; icon?: ExtensionIcon; order?: number; disabled?: boolean | ((context: EditorActionContext) => boolean); visible?: ExtensionVisibility; run: ExtensionAction; }
+export interface DocumentMenuActionContext extends EditorActionContext { title?: string; }
+export type DocumentMenuAction = (context: DocumentMenuActionContext) => void | Promise<void>;
+export interface DocumentMenuActionExtension { id: string; label: string; icon?: ExtensionIcon; order?: number; destructive?: boolean; disabled?: boolean | ((context: DocumentMenuActionContext) => boolean); visible?: ExtensionVisibility; run: DocumentMenuAction; }
+export interface SettingsSectionProps { userId?: string; }
+export interface SettingsSectionExtension { id: string; label: string; component: Component<SettingsSectionProps>; order?: number; description?: string; visible?: ExtensionVisibility; }
+export interface CommandPaletteActionContext { query?: string; }
+export type CommandPaletteAction = (context: CommandPaletteActionContext) => void | Promise<void>;
+export interface CommandPaletteActionExtension { id: string; label: string; keywords?: readonly string[]; group?: string; shortcut?: string; icon?: ExtensionIcon; order?: number; disabled?: boolean; visible?: ExtensionVisibility; run: CommandPaletteAction; }
+export interface SharedDocumentExtensionContext { shareToken: string; documentId: string; title: string; content: string; contentJson?: object; role: "viewer" | "commenter" | "editor"; permissions: { read: true; annotate: boolean; edit: boolean; export: boolean; }; }
+export interface SharedDocumentExtension { id: string; label: string; icon?: ExtensionIcon; order?: number; permission: "annotate" | "edit"; visible?: (context: SharedDocumentExtensionContext) => boolean; component: Component<{ context: SharedDocumentExtensionContext }>; }
+export interface DocsmintFrontendExtensions { navigation: readonly NavigationExtension[]; dashboardWidgets: readonly DashboardWidgetExtension[]; searchWidgets: readonly SearchWidgetExtension[]; documentTabs: readonly DocTabDefinition[]; editorActions: readonly EditorActionExtension[]; documentMenuActions: readonly DocumentMenuActionExtension[]; settingsSections: readonly SettingsSectionExtension[]; commandPaletteActions: readonly CommandPaletteActionExtension[]; sharedDocumentHeaderActions: readonly SharedDocumentExtension[]; sharedDocumentTabs: readonly SharedDocumentExtension[]; sharedDocumentNotesModes: readonly SharedDocumentExtension[]; sharedDocumentEditorModes: readonly SharedDocumentExtension[]; }
+/** @deprecated Use DocsmintFrontendExtensions. */
+export type HiaiDocsFrontendExtensions = DocsmintFrontendExtensions;
+export type FrontendExtensions = DocsmintFrontendExtensions;
+export interface DocsmintExtensionProviderProps { extensions?: Partial<DocsmintFrontendExtensions>; children: Snippet; }
+export declare const DocsmintExtensionProvider: Component<DocsmintExtensionProviderProps>;

package/dist/frontend/shared-document.d.ts

@@ -1,3 +1,16 @@
 import type { Component } from "svelte";
 export declare const DocsmintSharedDocumentHost: Component;
-export declare function renderSharedDocument(...args: readonly unknown[]): unknown;
+export interface ProseMirrorNode {
+  type: string;
+  text?: string;
+  content?: ProseMirrorNode[];
+  attrs?: Record<string, unknown>;
+  marks?: Array<{ type: string; attrs?: Record<string, unknown> }>;
+}
+export type ProseMirrorDoc = ProseMirrorNode & { content?: ProseMirrorNode[] };
+export type SharedAttachmentObjectUrls = string[];
+export declare function renderSharedDocument(doc: ProseMirrorDoc): string;
+export declare function markMarkdownTaskItems(html: string): string;
+export declare function sharedAttachmentHeaders(token: string, password?: string): HeadersInit;
+export declare function hydrateSharedAttachmentImages(root: ParentNode, token: string, password?: string): Promise<SharedAttachmentObjectUrls>;
+export declare function waitForSharedDocumentImages(root: ParentNode): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiai-gg/docsmint",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "type": "module",
   "browser": {
     "./dist/lifecycle.js": false,
@@ -51,6 +51,11 @@
       "import": "./dist/lifecycle.js",
       "types": "./dist/lifecycle.d.ts"
     },
+    "./lifecycle/persistent": {
+      "browser": "./dist/server-only-browser-entry.js",
+      "import": "./dist/lifecycle-persistent.js",
+      "types": "./dist/lifecycle-persistent.d.ts"
+    },
     "./workspace": {
       "browser": "./dist/server-only-browser-entry.js",
       "import": "./dist/workspace.js",
@@ -161,6 +166,7 @@
     "backend/src/lib/redis-factory.ts",
     "backend/src/lib/storage-factory.ts",
     "backend/src/lib/logger.ts",
+    "backend/src/lib/lifecycle-service.ts",
     "README.md",
     "LICENSE"
   ],

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.2";
+const VERSION = "0.3.3";
 
 const program = new Command();
 program

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

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