@hiai-gg/docsmint 0.4.1 → 0.4.3

package/dist/backend/index.js

@@ -214237,7 +214237,7 @@ var swaggerConfig = {
   documentation: {
     info: {
       title: "DocsMint API",
-      version: "0.4.1",
+      version: "0.4.3",
       description: "Self-hosted AI-first documentation platform. Full-text + semantic search, version history, sharing, and folder organization.",
       contact: { name: "HiAi-gg", url: "https://github.com/HiAi-gg/docsmint" },
       license: {

package/dist/lifecycle-persistent.js

@@ -12,22 +12,60 @@ export function createPersistentLifecycleRuntime(options) {
     const lifecycle = createUserDataLifecycle({
         async *exportUserData(context) {
             const immutable = immutableContext(context);
-            const records = await options.runtime.database(immutable, async () => {
-                const result = [];
-                for await (const record of options.runtime.adapter.exportUserData(immutable))
-                    result.push(record);
-                return result;
-            });
+            const records = await options.runtime.database(immutable, () => composeExport(options.runtime.adapter, hostSteps, immutable));
             for (const record of records)
                 yield record;
         },
         async purgeUserData(context, gate) {
             const immutable = immutableContext(context);
-            return options.runtime.database(immutable, () => options.runtime.adapter.purgeUserData(immutable, gate));
+            return options.runtime.database(immutable, async () => {
+                const result = await options.runtime.adapter.purgeUserData(immutable, gate);
+                if (result.status === "already_completed")
+                    return result;
+                const deletedByDomain = { ...result.deletedByDomain };
+                for (const step of hostSteps) {
+                    if (!step.purge)
+                        continue;
+                    const outcome = await step.purge(immutable);
+                    deletedByDomain[`host:${step.id}`] = outcome.deletedCount;
+                }
+                return { ...result, deletedByDomain };
+            });
         },
     }, async (context) => options.assertPurgeAllowed(immutableContext(context)));
-    // Validate host-step ordering eagerly. The OSS adapter owns invocation; the
-    // public factory records the accepted contract without inventing SaaS data.
-    void hostSteps;
     return lifecycle;
 }
+async function composeExport(adapter, hostSteps, context) {
+    const ossRecords = [];
+    for await (const record of adapter.exportUserData(context))
+        ossRecords.push(record);
+    const manifest = ossRecords.shift();
+    const complete = ossRecords.pop();
+    if (manifest?.type !== "manifest" || complete?.type !== "complete") {
+        throw new Error("Persistent lifecycle adapter returned an invalid export stream");
+    }
+    if (ossRecords.some((record) => record.type === "manifest" || record.type === "complete")) {
+        throw new Error("Persistent lifecycle adapter returned a reserved record type");
+    }
+    const hash = new Bun.CryptoHasher("sha256");
+    const records = [];
+    const append = (record) => {
+        hash.update(`${JSON.stringify(record)}\n`, "utf8");
+        records.push(record);
+    };
+    append(manifest);
+    for (const record of ossRecords)
+        append(record);
+    for (const step of hostSteps) {
+        if (!step.export)
+            continue;
+        for await (const record of step.export(context)) {
+            if (record.type === "manifest" || record.type === "complete") {
+                throw new Error(`Lifecycle host step ${step.id} emitted a reserved record type`);
+            }
+            append(record);
+        }
+    }
+    records.push({ type: "complete", recordCount: records.length, checksum: hash.digest("hex") });
+    return records;
+}

package/dist/lifecycle-runtime.d.ts

@@ -0,0 +1,35 @@
+import type { AssertPurgeAllowed, LifecycleHostStep, UserDataLifecycle } from "./lifecycle";
+/**
+ * Server-only external effects required by the durable OSS lifecycle saga.
+ * Implementations must perform real deletion work; the runtime deliberately
+ * has no permissive defaults for queues, object storage, Redis, collaboration,
+ * or graph state.
+ */
+export type LifecycleRuntimeAdapters = Readonly<{
+    verifyPurgeFence: (context: Parameters<AssertPurgeAllowed>[0], 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>;
+}>;
+/**
+ * Host-owned request/RLS transaction executor. TTransaction is intentionally
+ * generic so a consumer can retain the exact Drizzle transaction type without
+ * this public contract importing its database singleton.
+ */
+export type LifecycleScopedDatabaseExecutor<TTransaction = unknown> = Readonly<{
+    withActorTransaction<T>(actorUserId: string, operation: (transaction: TTransaction) => Promise<T>): Promise<T>;
+}>;
+export type PersistentLifecycleRuntimeOptions<TTransaction = unknown> = Readonly<{
+    runtime: LifecycleRuntimeAdapters;
+    database: LifecycleScopedDatabaseExecutor<TTransaction>;
+    assertPurgeAllowed: AssertPurgeAllowed;
+    hostSteps?: readonly LifecycleHostStep[];
+}>;
+/**
+ * Creates the concrete durable PostgreSQL lifecycle saga shipped by DocsMint.
+ * The JavaScript implementation is bundled from the OSS backend at build time;
+ * this source file is the stable public declaration surface.
+ */
+export declare function createPersistentLifecycleRuntime<TTransaction = unknown>(options: PersistentLifecycleRuntimeOptions<TTransaction>): UserDataLifecycle;

package/dist/lifecycle-runtime.js

@@ -0,0 +1,811 @@
+// @bun
+// ../db/src/schema.ts
+import { pgTable, uuid, text, timestamp, bigint, jsonb, index, uniqueIndex, customType, boolean, check, integer, pgEnum } from "drizzle-orm/pg-core";
+import { relations, sql } from "drizzle-orm";
+var vector = customType({
+  dataType(config) {
+    return `vector(${config.dimensions})`;
+  },
+  toDriver(value) {
+    return JSON.stringify(value);
+  },
+  fromDriver(value) {
+    if (typeof value === "string")
+      return JSON.parse(value);
+    return value;
+  }
+});
+var tsvector = customType({
+  dataType() {
+    return "tsvector";
+  }
+});
+var documentVisibilityEnum = pgEnum("document_visibility", ["private", "shared", "public"]);
+var shareRoleEnum = pgEnum("share_role", ["viewer", "commenter", "editor"]);
+var embeddingStatusEnum = pgEnum("embedding_status", [
+  "pending",
+  "processing",
+  "ready",
+  "failed",
+  "stale"
+]);
+var pipelineStageEnum = pgEnum("pipeline_stage", [
+  "prepare",
+  "embed",
+  "graph",
+  "summarize",
+  "finalize"
+]);
+var pipelineStatusEnum = pgEnum("pipeline_status", [
+  "pending",
+  "processing",
+  "ready",
+  "retrying",
+  "failed",
+  "ready_with_warnings",
+  "skipped",
+  "cancelled"
+]);
+var lifecycleOperationKindEnum = pgEnum("lifecycle_operation_kind", [
+  "export",
+  "purge"
+]);
+var lifecycleOperationStatusEnum = pgEnum("lifecycle_operation_status", [
+  "pending",
+  "running",
+  "retryable",
+  "completed",
+  "rejected"
+]);
+var users = pgTable("users", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  email: text("email").notNull().unique(),
+  name: text("name"),
+  emailVerified: boolean("email_verified").default(false),
+  image: text("image"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+});
+var sessions = pgTable("sessions", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  token: text("token").notNull().unique(),
+  expiresAt: timestamp("expires_at").notNull(),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  revokedAt: timestamp("revoked_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  index("sessions_user_id_idx").on(table.userId),
+  index("sessions_revoked_at_idx").on(table.revokedAt).where(sql`${table.revokedAt} IS NOT NULL`)
+]);
+var accounts = pgTable("accounts", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  userId: uuid("user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  accountId: text("account_id").notNull(),
+  providerId: text("provider_id").notNull(),
+  accessToken: text("access_token"),
+  refreshToken: text("refresh_token"),
+  accessTokenExpiresAt: timestamp("access_token_expires_at"),
+  refreshTokenExpiresAt: timestamp("refresh_token_expires_at"),
+  scope: text("scope"),
+  password: text("password"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  index("accounts_user_id_idx").on(table.userId),
+  uniqueIndex("accounts_provider_account_idx").on(table.providerId, table.accountId)
+]);
+var verifications = pgTable("verifications", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  identifier: text("identifier").notNull(),
+  value: text("value").notNull(),
+  expiresAt: timestamp("expires_at").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  index("verifications_identifier_idx").on(table.identifier)
+]);
+var folders = pgTable("folders", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  parentId: uuid("parent_id").references(() => folders.id, {
+    onDelete: "set null"
+  }),
+  categoryId: uuid("category_id").references(() => categories.id, {
+    onDelete: "set null"
+  }),
+  name: text("name").notNull(),
+  order: integer("order").notNull().default(0),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  index("folders_owner_id_idx").on(table.ownerId),
+  index("folders_parent_id_idx").on(table.parentId),
+  index("folders_category_id_idx").on(table.categoryId)
+]);
+var folderRelations = relations(folders, ({ one, many }) => ({
+  owner: one(users, { fields: [folders.ownerId], references: [users.id] }),
+  parent: one(folders, {
+    fields: [folders.parentId],
+    references: [folders.id],
+    relationName: "folderParent"
+  }),
+  category: one(categories, {
+    fields: [folders.categoryId],
+    references: [categories.id]
+  }),
+  children: many(folders, { relationName: "folderParent" }),
+  documents: many(documents)
+}));
+var documents = pgTable("documents", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  folderId: uuid("folder_id").references(() => folders.id, {
+    onDelete: "set null"
+  }),
+  categoryId: uuid("category_id").references(() => categories.id, {
+    onDelete: "set null"
+  }),
+  title: text("title").notNull().default("Untitled"),
+  content: text("content").default(""),
+  contentJson: jsonb("content_json"),
+  metadata: jsonb("metadata"),
+  visibility: documentVisibilityEnum("visibility").notNull().default("private"),
+  contentHash: text("content_hash"),
+  lastSignificantHash: text("last_significant_hash"),
+  lastSignificantUpdateAt: timestamp("last_significant_update_at"),
+  pendingMinorChanges: boolean("pending_minor_changes").default(false).notNull(),
+  metadataChangedAt: timestamp("metadata_changed_at"),
+  searchVector: tsvector("search_vector").generatedAlwaysAs(sql`to_tsvector('english', left(COALESCE(title, '') || ' ' || regexp_replace(COALESCE(content, ''), 'data:[^[:space:])>]+', ' ', 'g'), 200000))`),
+  searchVectorSimple: tsvector("search_vector_simple").generatedAlwaysAs(sql`to_tsvector('simple', left(COALESCE(title, '') || ' ' || regexp_replace(COALESCE(content, ''), 'data:[^[:space:])>]+', ' ', 'g'), 200000))`),
+  embeddingStatus: embeddingStatusEnum("embedding_status").notNull().default("pending"),
+  activeEmbeddingGeneration: uuid("active_embedding_generation"),
+  pendingEmbeddingGeneration: uuid("pending_embedding_generation"),
+  embeddingProfile: text("embedding_profile"),
+  embeddingErrorCode: text("embedding_error_code"),
+  embeddingUpdatedAt: timestamp("embedding_updated_at"),
+  deletedAt: timestamp("deleted_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  index("documents_owner_id_idx").on(table.ownerId),
+  index("documents_folder_id_idx").on(table.folderId),
+  index("documents_category_id_idx").on(table.categoryId),
+  index("documents_created_at_idx").on(table.createdAt),
+  index("idx_documents_search_vector").using("gin", table.searchVector),
+  index("idx_documents_search_vector_simple").using("gin", table.searchVectorSimple),
+  index("documents_embedding_status_idx").on(table.embeddingStatus),
+  index("documents_workspace_deleted_at_idx").on(table.workspaceId, table.deletedAt),
+  index("idx_documents_title_trgm").using("gin", sql`${table.title} gin_trgm_ops`)
+]);
+var documentRelations = relations(documents, ({ one, many }) => ({
+  owner: one(users, { fields: [documents.ownerId], references: [users.id] }),
+  folder: one(folders, {
+    fields: [documents.folderId],
+    references: [folders.id]
+  }),
+  category: one(categories, {
+    fields: [documents.categoryId],
+    references: [categories.id]
+  }),
+  tags: many(documentTags),
+  attachments: many(attachments),
+  versions: many(versions)
+}));
+var documentPipelineRuns = pgTable("document_pipeline_runs", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  generationId: uuid("generation_id").notNull(),
+  revision: text("revision").notNull(),
+  source: text("source").notNull(),
+  status: pipelineStatusEnum("status").notNull().default("pending"),
+  prepareStatus: pipelineStatusEnum("prepare_status").notNull().default("pending"),
+  embedStatus: pipelineStatusEnum("embed_status").notNull().default("pending"),
+  graphStatus: pipelineStatusEnum("graph_status").notNull().default("pending"),
+  summarizeStatus: pipelineStatusEnum("summarize_status").notNull().default("pending"),
+  finalizeStatus: pipelineStatusEnum("finalize_status").notNull().default("pending"),
+  totalBatches: integer("total_batches").notNull().default(0),
+  completedBatches: integer("completed_batches").notNull().default(0),
+  failedBatches: integer("failed_batches").notNull().default(0),
+  errorCode: text("error_code"),
+  attempts: integer("attempts").notNull().default(0),
+  requestedAt: timestamp("requested_at").defaultNow().notNull(),
+  startedAt: timestamp("started_at"),
+  completedAt: timestamp("completed_at"),
+  heartbeatAt: timestamp("heartbeat_at"),
+  availableAt: timestamp("available_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  uniqueIndex("document_pipeline_runs_document_generation_idx").on(table.documentId, table.generationId),
+  index("document_pipeline_runs_owner_status_updated_idx").on(table.ownerId, table.status, table.updatedAt)
+]);
+var documentPipelineBatches = pgTable("document_pipeline_batches", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  workspaceId: text("workspace_id"),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  generationId: uuid("generation_id").notNull(),
+  batchIndex: integer("batch_index").notNull(),
+  stage: pipelineStageEnum("stage").notNull().default("embed"),
+  chunkStart: integer("chunk_start").notNull(),
+  chunkEnd: integer("chunk_end").notNull(),
+  status: pipelineStatusEnum("status").notNull().default("pending"),
+  attempts: integer("attempts").notNull().default(0),
+  embeddingProfile: text("embedding_profile"),
+  errorCode: text("error_code"),
+  availableAt: timestamp("available_at"),
+  startedAt: timestamp("started_at"),
+  completedAt: timestamp("completed_at"),
+  heartbeatAt: timestamp("heartbeat_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  uniqueIndex("document_pipeline_batches_generation_index_idx").on(table.generationId, table.batchIndex),
+  index("document_pipeline_batches_stage_status_available_idx").on(table.stage, table.status, table.availableAt),
+  index("document_pipeline_batches_document_id_idx").on(table.documentId)
+]);
+var tags = pgTable("tags", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  name: text("name").notNull(),
+  color: text("color"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("tags_owner_id_idx").on(table.ownerId),
+  uniqueIndex("tags_owner_name_idx").on(table.ownerId, table.name)
+]);
+var tagRelations = relations(tags, ({ many }) => ({
+  documents: many(documentTags)
+}));
+var categories = pgTable("categories", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  name: text("name").notNull(),
+  order: integer("order").notNull().default(0),
+  apiMode: text("api_mode").notNull().default("unavailable"),
+  apiPermissionRead: boolean("api_permission_read").notNull().default(false),
+  apiPermissionEdit: boolean("api_permission_edit").notNull().default(false),
+  apiPermissionWrite: boolean("api_permission_write").notNull().default(false),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  updatedAt: timestamp("updated_at").defaultNow().notNull()
+}, (table) => [
+  index("categories_owner_id_idx").on(table.ownerId),
+  index("categories_api_mode_idx").on(table.apiMode)
+]);
+var categoryRelations = relations(categories, ({ one, many }) => ({
+  owner: one(users, { fields: [categories.ownerId], references: [users.id] }),
+  folders: many(folders),
+  documents: many(documents)
+}));
+var documentTags = pgTable("document_tags", {
+  workspaceId: text("workspace_id"),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  tagId: uuid("tag_id").notNull().references(() => tags.id, { onDelete: "cascade" })
+}, (table) => [
+  uniqueIndex("document_tags_unique_idx").on(table.documentId, table.tagId)
+]);
+var documentTagRelations = relations(documentTags, ({ one }) => ({
+  document: one(documents, {
+    fields: [documentTags.documentId],
+    references: [documents.id]
+  }),
+  tag: one(tags, { fields: [documentTags.tagId], references: [tags.id] })
+}));
+var shareLinks = pgTable("share_links", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  documentId: uuid("document_id").references(() => documents.id, {
+    onDelete: "cascade"
+  }),
+  folderId: uuid("folder_id").references(() => folders.id, {
+    onDelete: "cascade"
+  }),
+  categoryId: uuid("category_id").references(() => categories.id, {
+    onDelete: "cascade"
+  }),
+  token: text("token").notNull().unique(),
+  passwordHash: text("password_hash"),
+  role: shareRoleEnum("role").notNull().default("viewer"),
+  expiresAt: timestamp("expires_at"),
+  createdBy: uuid("created_by").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("share_links_token_idx").on(table.token),
+  index("share_links_document_id_idx").on(table.documentId),
+  index("share_links_folder_id_idx").on(table.folderId),
+  index("share_links_category_id_idx").on(table.categoryId),
+  check("share_links_exactly_one_target_check", sql`num_nonnulls(${table.documentId}, ${table.folderId}, ${table.categoryId}) = 1`)
+]);
+var shareLinkRelations = relations(shareLinks, ({ one, many }) => ({
+  document: one(documents, {
+    fields: [shareLinks.documentId],
+    references: [documents.id]
+  }),
+  folder: one(folders, {
+    fields: [shareLinks.folderId],
+    references: [folders.id]
+  }),
+  category: one(categories, {
+    fields: [shareLinks.categoryId],
+    references: [categories.id]
+  }),
+  creator: one(users, {
+    fields: [shareLinks.createdBy],
+    references: [users.id]
+  }),
+  guestAccess: many(guestAccess)
+}));
+var guestAccess = pgTable("guest_access", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  shareLinkId: uuid("share_link_id").notNull().references(() => shareLinks.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  guestEmail: text("guest_email").notNull(),
+  grantedAt: timestamp("granted_at").defaultNow().notNull()
+}, (table) => [index("guest_access_share_link_idx").on(table.shareLinkId)]);
+var guestAccessRelations = relations(guestAccess, ({ one }) => ({
+  shareLink: one(shareLinks, {
+    fields: [guestAccess.shareLinkId],
+    references: [shareLinks.id]
+  })
+}));
+var attachments = pgTable("attachments", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  filename: text("filename").notNull(),
+  mimeType: text("mime_type").notNull(),
+  size: bigint("size", { mode: "number" }).notNull(),
+  storageKey: text("storage_key").notNull(),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [index("attachments_document_id_idx").on(table.documentId)]);
+var attachmentRelations = relations(attachments, ({ one }) => ({
+  document: one(documents, {
+    fields: [attachments.documentId],
+    references: [documents.id]
+  })
+}));
+var versions = pgTable("versions", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  content: text("content").notNull(),
+  contentJson: jsonb("content_json"),
+  createdBy: uuid("created_by").notNull().references(() => users.id, { onDelete: "cascade" }),
+  createdAt: timestamp("created_at").defaultNow().notNull(),
+  label: text("label"),
+  description: text("description"),
+  isSnapshot: boolean("is_snapshot").default(false),
+  restoredFrom: uuid("restored_from")
+}, (table) => [
+  index("versions_document_id_idx").on(table.documentId),
+  index("versions_created_at_idx").on(table.createdAt),
+  index("versions_is_snapshot_idx").on(table.isSnapshot)
+]);
+var documentEmbeddings = pgTable("document_embeddings", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  chunkIndex: bigint("chunk_index", { mode: "number" }).notNull(),
+  chunkText: text("chunk_text").notNull(),
+  chunkHash: text("chunk_hash"),
+  charStart: integer("char_start").notNull().default(0),
+  charEnd: integer("char_end").notNull().default(0),
+  embedding: vector("embedding", { dimensions: 1024 }),
+  embeddingModel: text("embedding_model").notNull().default(""),
+  generationId: uuid("generation_id").notNull(),
+  embeddingDimensions: integer("embedding_dimensions").notNull().default(1024),
+  embeddingProfile: text("embedding_profile").notNull().default("legacy"),
+  isValid: boolean("is_valid").notNull().default(false),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("document_embeddings_doc_id_idx").on(table.documentId),
+  uniqueIndex("document_embeddings_doc_chunk_idx").on(table.documentId, table.generationId, table.chunkIndex),
+  index("document_embeddings_generation_valid_idx").on(table.documentId, table.generationId, table.isValid),
+  index("idx_document_embeddings_embedding_model").on(table.embeddingModel),
+  index("idx_document_embeddings_hnsw").using("hnsw", sql`${table.embedding} vector_cosine_ops`),
+  index("idx_document_embeddings_diskann").using("diskann", sql`${table.embedding} vector_cosine_ops`)
+]);
+var documentEmbeddingRelations = relations(documentEmbeddings, ({ one }) => ({
+  document: one(documents, {
+    fields: [documentEmbeddings.documentId],
+    references: [documents.id]
+  })
+}));
+var apiKeys = pgTable("api_keys", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  ownerId: uuid("owner_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  workspaceId: text("workspace_id"),
+  name: text("name").notNull(),
+  keyHash: text("key_hash").notNull().unique(),
+  prefix: text("prefix").notNull(),
+  encryptedKey: text("encrypted_key"),
+  scopes: jsonb("scopes").notNull().default("[]"),
+  lastUsedAt: timestamp("last_used_at"),
+  expiresAt: timestamp("expires_at"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("idx_api_keys_owner").on(table.ownerId),
+  index("idx_api_keys_prefix").on(table.prefix)
+]);
+var apiKeyRelations = relations(apiKeys, ({ one }) => ({
+  owner: one(users, { fields: [apiKeys.ownerId], references: [users.id] })
+}));
+var auditLog = pgTable("audit_log", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  actorId: uuid("actor_id").notNull(),
+  workspaceId: text("workspace_id"),
+  action: text("action").notNull(),
+  resourceType: text("resource_type").notNull(),
+  resourceId: uuid("resource_id"),
+  details: jsonb("details").notNull().default("{}"),
+  ipAddress: text("ip_address"),
+  userAgent: text("user_agent"),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  index("idx_audit_log_actor").on(table.actorId),
+  index("idx_audit_log_resource").on(table.resourceType, table.resourceId),
+  index("idx_audit_log_created").on(table.createdAt)
+]);
+var lifecycleOperations = pgTable("lifecycle_operations", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  actorUserId: uuid("actor_user_id").references(() => users.id, { onDelete: "set null" }),
+  actorSubjectHash: text("actor_subject_hash").notNull(),
+  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'`),
+  check("lifecycle_operations_actor_subject_hash", sql`${table.actorSubjectHash} ~ '^[a-f0-9]{64}$'`)
+]);
+var documentCreateOperations = pgTable("document_create_operations", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  workspaceId: text("workspace_id").notNull(),
+  actorUserId: uuid("actor_user_id").notNull().references(() => users.id, { onDelete: "cascade" }),
+  idempotencyKey: text("idempotency_key").notNull(),
+  documentId: uuid("document_id").notNull().references(() => documents.id, { onDelete: "cascade" }),
+  createdAt: timestamp("created_at").defaultNow().notNull()
+}, (table) => [
+  uniqueIndex("document_create_operations_workspace_actor_key_idx").on(table.workspaceId, table.actorUserId, table.idempotencyKey),
+  uniqueIndex("document_create_operations_document_idx").on(table.documentId)
+]);
+var versionRelations = relations(versions, ({ one }) => ({
+  document: one(documents, {
+    fields: [versions.documentId],
+    references: [documents.id]
+  }),
+  creator: one(users, {
+    fields: [versions.createdBy],
+    references: [users.id]
+  })
+}));
+
+// ../../backend/src/lib/lifecycle-service.ts
+import { and, eq, inArray, lt, or, sql as sql2 } from "drizzle-orm";
+var LEASE_MS = 60000;
+
+class LifecycleFenceRejectedError extends Error {
+  code = "fence_rejected";
+  constructor(message = "Purge fence rejected") {
+    super(message);
+    this.name = "LifecycleFenceRejectedError";
+  }
+}
+
+class LifecycleLeaseLostError extends Error {
+  code = "lease_lost";
+  constructor() {
+    super("Lifecycle operation lease was lost");
+    this.name = "LifecycleLeaseLostError";
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw signal.reason ?? new DOMException("Aborted", "AbortError");
+}
+function safeErrorCode(error) {
+  if (error instanceof DOMException && error.name === "AbortError")
+    return "aborted";
+  if (error instanceof LifecycleFenceRejectedError)
+    return error.code;
+  if (error instanceof LifecycleLeaseLostError)
+    return error.code;
+  return "persistence_failed";
+}
+function tokenHash(token) {
+  return new Bun.CryptoHasher("sha256").update(token).digest("hex");
+}
+function subjectHash(actorUserId) {
+  return new Bun.CryptoHasher("sha256").update(actorUserId).digest("hex");
+}
+function checksumLine(hash, record) {
+  hash.update(`${JSON.stringify(record)}
+`, "utf8");
+}
+function counts(value) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function operationCounts(operation) {
+  const result = operation.terminalResult;
+  return counts(result?.deletedByDomain);
+}
+function requireLeaseWrite(rows) {
+  if (rows.length !== 1)
+    throw new LifecycleLeaseLostError;
+}
+function createPersistentLifecycleService(runtime, database, hostSteps = []) {
+  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");
+  }
+  const withActor = (actorUserId, operation) => database.withActorTransaction(actorUserId, operation);
+  async function getOrCreateOperation(ctx) {
+    return withActor(ctx.actorUserId, async (tx) => {
+      await tx.insert(lifecycleOperations).values({
+        actorUserId: ctx.actorUserId,
+        actorSubjectHash: subjectHash(ctx.actorUserId),
+        idempotencyKey: ctx.idempotencyKey,
+        operationKind: "purge",
+        status: "pending"
+      }).onConflictDoNothing();
+      const operation = await tx.query.lifecycleOperations.findFirst({
+        where: and(eq(lifecycleOperations.actorUserId, ctx.actorUserId), eq(lifecycleOperations.idempotencyKey, ctx.idempotencyKey))
+      });
+      if (operation?.operationKind !== "purge")
+        throw new Error("persistence_failed");
+      return operation;
+    });
+  }
+  async function acquireLease(operation, actorUserId, owner) {
+    return withActor(actorUserId, async (tx) => {
+      const now = new Date;
+      const expiry = new Date(now.getTime() + LEASE_MS);
+      const updated = await tx.update(lifecycleOperations).set({
+        status: "running",
+        leaseOwner: owner,
+        leaseExpiresAt: expiry,
+        attemptCount: sql2`${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(actorUserId, operationId, leaseOwner, step, deletedByDomain) {
+    await withActor(actorUserId, async (tx) => {
+      const current = await tx.query.lifecycleOperations.findFirst({
+        where: and(eq(lifecycleOperations.id, operationId), eq(lifecycleOperations.leaseOwner, leaseOwner))
+      });
+      if (current?.status !== "running" || current.leaseExpiresAt && current.leaseExpiresAt < new Date) {
+        throw new LifecycleLeaseLostError;
+      }
+      const completed = Array.isArray(current.completedSteps) ? current.completedSteps.filter((value) => typeof value === "string") : [];
+      if (!completed.includes(step))
+        completed.push(step);
+      const updated = await tx.update(lifecycleOperations).set({
+        completedSteps: completed,
+        terminalResult: { deletedByDomain },
+        updatedAt: new Date
+      }).where(and(eq(lifecycleOperations.id, operationId), eq(lifecycleOperations.leaseOwner, leaseOwner))).returning({ id: lifecycleOperations.id });
+      requireLeaseWrite(updated);
+    });
+  }
+  async function runStep(operation, actorUserId, leaseOwner, step, deletedByDomain, action) {
+    const completed = Array.isArray(operation.completedSteps) ? operation.completedSteps : [];
+    if (completed.includes(step))
+      return;
+    const count = await action();
+    deletedByDomain[step] = count;
+    await persistStep(actorUserId, 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 = {
+        type: "manifest",
+        schemaVersion: 1,
+        exportId,
+        actorUserId: ctx.actorUserId,
+        generatedAt: new Date().toISOString()
+      };
+      checksumLine(hash, manifest);
+      recordCount += 1;
+      yield manifest;
+      const ownedDocuments = await withActor(ctx.actorUserId, (tx) => tx.select().from(documents).where(eq(documents.ownerId, ctx.actorUserId)));
+      for (const document of ownedDocuments) {
+        throwIfAborted(ctx.signal);
+        const record = {
+          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 withActor(ctx.actorUserId, (tx) => tx.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 = {
+          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, ctx.actorUserId, leaseOwner))
+        throw new LifecycleLeaseLostError;
+      operation = await withActor(ctx.actorUserId, async (tx) => await tx.query.lifecycleOperations.findFirst({
+        where: eq(lifecycleOperations.id, operation.id)
+      }) ?? operation);
+      const deletedByDomain = operationCounts(operation);
+      try {
+        throwIfAborted(ctx.signal);
+        await withActor(ctx.actorUserId, async (tx) => {
+          const updated = await tx.update(lifecycleOperations).set({
+            fenceTokenHash: tokenHash(gate.fenceToken),
+            updatedAt: new Date
+          }).where(and(eq(lifecycleOperations.id, operation.id), eq(lifecycleOperations.leaseOwner, leaseOwner))).returning({ id: lifecycleOperations.id });
+          requireLeaseWrite(updated);
+        });
+        await runtime.verifyPurgeFence(ctx, gate.fenceToken);
+        const dbDelete = (action) => withActor(ctx.actorUserId, action).then((rows) => rows.length);
+        await runStep(operation, ctx.actorUserId, leaseOwner, "cancel_account_jobs", deletedByDomain, () => runtime.cancelAccountJobs(ctx.actorUserId, ctx.signal));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_collaboration_state", deletedByDomain, () => runtime.removeCollaborationState(ctx.actorUserId, ctx.signal));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_subject_created_shares", deletedByDomain, () => dbDelete((tx) => tx.delete(shareLinks).where(eq(shareLinks.createdBy, ctx.actorUserId)).returning({ id: shareLinks.id })));
+        const owned = await withActor(ctx.actorUserId, (tx) => tx.select({ id: documents.id }).from(documents).where(eq(documents.ownerId, ctx.actorUserId)));
+        const documentIds = owned.map((row) => row.id);
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_document_versions", deletedByDomain, () => documentIds.length ? dbDelete((tx) => tx.delete(versions).where(inArray(versions.documentId, documentIds)).returning({ id: versions.id })) : Promise.resolve(0));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_chunks_and_embeddings", deletedByDomain, () => documentIds.length ? dbDelete((tx) => tx.delete(documentEmbeddings).where(inArray(documentEmbeddings.documentId, documentIds)).returning({ id: documentEmbeddings.id })) : Promise.resolve(0));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_graph_state", deletedByDomain, () => runtime.removeGraphState(documentIds, ctx.signal));
+        const objectRows = documentIds.length ? await withActor(ctx.actorUserId, (tx) => tx.select({
+          id: attachments.id,
+          storageKey: attachments.storageKey
+        }).from(attachments).where(inArray(attachments.documentId, documentIds))) : [];
+        await runStep(operation, ctx.actorUserId, leaseOwner, "delete_attachment_objects", deletedByDomain, () => runtime.deleteObjects(objectRows.map((row) => row.storageKey), ctx.signal));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_attachment_rows", deletedByDomain, () => objectRows.length ? dbDelete((tx) => tx.delete(attachments).where(inArray(attachments.id, objectRows.map((row) => row.id))).returning({ id: attachments.id })) : Promise.resolve(0));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "remove_subject_documents", deletedByDomain, () => dbDelete((tx) => tx.delete(documents).where(eq(documents.ownerId, ctx.actorUserId)).returning({ id: documents.id })));
+        await runStep(operation, ctx.actorUserId, leaseOwner, "clear_redis_state", deletedByDomain, () => runtime.clearAccountRedisState(ctx.actorUserId, ctx.signal));
+        for (const step of orderedSteps)
+          if (step.purge)
+            await runStep(operation, ctx.actorUserId, leaseOwner, `host:${step.id}`, deletedByDomain, async () => (await step.purge?.(ctx))?.deletedCount ?? 0);
+        await runStep(operation, ctx.actorUserId, leaseOwner, "write_deletion_audit", deletedByDomain, async () => {
+          await withActor(ctx.actorUserId, (tx) => tx.insert(auditLog).values({
+            actorId: ctx.actorUserId,
+            action: "account_data_purged",
+            resourceType: "lifecycle_operation",
+            details: {
+              operationId: operation.id,
+              outcome: "completed",
+              deletedByDomain
+            }
+          }));
+          return 1;
+        });
+        await withActor(ctx.actorUserId, async (tx) => {
+          const updated = await tx.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))).returning({ id: lifecycleOperations.id });
+          requireLeaseWrite(updated);
+        });
+        return {
+          status: "completed",
+          operationId: operation.id,
+          deletedByDomain
+        };
+      } catch (error) {
+        if (error instanceof LifecycleLeaseLostError)
+          throw error;
+        const code = safeErrorCode(error);
+        await withActor(ctx.actorUserId, async (tx) => {
+          const updated = await tx.update(lifecycleOperations).set({
+            status: error instanceof LifecycleFenceRejectedError ? "rejected" : "retryable",
+            safeErrorCode: code,
+            leaseOwner: null,
+            leaseExpiresAt: null,
+            completedAt: error instanceof LifecycleFenceRejectedError ? new Date : null,
+            updatedAt: new Date
+          }).where(and(eq(lifecycleOperations.id, operation.id), eq(lifecycleOperations.leaseOwner, leaseOwner))).returning({ id: lifecycleOperations.id });
+          requireLeaseWrite(updated);
+        });
+        throw error;
+      }
+    }
+  };
+}
+function bindPersistentLifecycle(service, assertPurgeAllowed) {
+  return {
+    exportUserData: service.exportUserData,
+    async purgeUserData(ctx) {
+      const gate = await assertPurgeAllowed(ctx);
+      return service.purgeUserData(ctx, gate);
+    }
+  };
+}
+function createPersistentLifecycleRuntime(options) {
+  const service = createPersistentLifecycleService(options.runtime, options.database, options.hostSteps ?? []);
+  return bindPersistentLifecycle(service, options.assertPurgeAllowed);
+}
+export {
+  requireLeaseWrite,
+  createPersistentLifecycleService,
+  createPersistentLifecycleRuntime,
+  bindPersistentLifecycle,
+  LifecycleLeaseLostError,
+  LifecycleFenceRejectedError
+};

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@hiai-gg/docsmint",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "type": "module",
   "browser": {
     "./dist/backend-launcher.js": false,
     "./dist/lifecycle.js": false,
     "./dist/lifecycle-persistent.js": false,
+    "./dist/lifecycle-runtime.js": false,
     "./dist/storage-quota.js": false,
     "./dist/workspace.js": false
   },
@@ -59,6 +60,11 @@
       "import": "./dist/lifecycle-persistent.js",
       "types": "./dist/lifecycle-persistent.d.ts"
     },
+    "./lifecycle/runtime": {
+      "browser": "./dist/server-only-browser-entry.js",
+      "import": "./dist/lifecycle-runtime.js",
+      "types": "./dist/lifecycle-runtime.d.ts"
+    },
     "./workspace": {
       "browser": "./dist/server-only-browser-entry.js",
       "import": "./dist/workspace.js",

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.4.1";
+const VERSION = "0.4.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.4.1",
+	version: "0.4.3",
 });
 
 /**