@btst/stack 3.0.0-rc.2 → 3.0.0-rc.4

package/dist/packages/stack/src/plugins/kanban/api/operations.mjs

@@ -0,0 +1,1543 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { OperationHttpError, defineOperation } from '@btst/stack/plugins/api';
+import { z } from 'zod';
+import { kanbanPermissions } from '../../../../../../plugins/kanban/permissions.mjs';
+import { BoardListQuerySchema, createBoardSchema, createColumnSchema, reorderColumnsSchema, createTaskSchema, moveTaskSchema, reorderTasksSchema, updateBoardSchema, updateColumnSchema, updateTaskSchema } from '../schemas.mjs';
+import { slugify } from '../utils.mjs';
+import { getBoardSummaries, getBoardById } from './getters.mjs';
+import { serializeBoardSummary, serializeTask } from './serializers.mjs';
+
+const BoardIdOperationInputSchema = z.object({ id: z.string() });
+const UpdateBoardOperationInputSchema = z.object({
+  id: z.string(),
+  data: updateBoardSchema.omit({ id: true })
+});
+const ColumnIdOperationInputSchema = z.object({ id: z.string() });
+const UpdateColumnOperationInputSchema = z.object({
+  id: z.string(),
+  data: updateColumnSchema.omit({ id: true }).superRefine((data, context) => {
+    if (Object.hasOwn(data, "order") && data.order === void 0) {
+      context.addIssue({
+        code: "custom",
+        path: ["order"],
+        message: "Order must be a number when provided."
+      });
+    }
+  })
+});
+const TaskIdOperationInputSchema = z.object({ id: z.string() });
+const UpdateTaskOperationInputSchema = z.object({
+  id: z.string(),
+  data: updateTaskSchema.omit({ id: true })
+});
+class KanbanOperationError extends OperationHttpError {
+  constructor(statusCode, message, code) {
+    super(statusCode, message, code);
+    this.name = "KanbanOperationError";
+  }
+}
+function boardSnapshot(board) {
+  return {
+    id: board.id,
+    ...board.ownerId ? { ownerId: board.ownerId } : {},
+    ...board.organizationId ? { organizationId: board.organizationId } : {},
+    updatedAt: board.updatedAt
+  };
+}
+function columnSnapshot(column) {
+  return {
+    id: column.id,
+    boardId: column.boardId,
+    updatedAt: column.updatedAt
+  };
+}
+function taskSnapshot(task) {
+  return {
+    id: task.id,
+    columnId: task.columnId,
+    ...task.assigneeId ? { assigneeId: task.assigneeId } : {},
+    isArchived: task.isArchived,
+    updatedAt: task.updatedAt
+  };
+}
+function sameDate(left, right) {
+  return left.getTime() === right.getTime();
+}
+function sameBoard(board, expected) {
+  return board !== null && board.id === expected.id && (board.ownerId || void 0) === expected.ownerId && (board.organizationId || void 0) === expected.organizationId && sameDate(board.updatedAt, expected.updatedAt);
+}
+function sameColumn(column, expected) {
+  return column !== null && column.id === expected.id && column.boardId === expected.boardId && sameDate(column.updatedAt, expected.updatedAt);
+}
+function sameTask(task, expected) {
+  return task !== null && task.id === expected.id && task.columnId === expected.columnId && (task.assigneeId || void 0) === expected.assigneeId && task.isArchived === expected.isArchived && sameDate(task.updatedAt, expected.updatedAt);
+}
+function sameColumnSnapshots(left, right) {
+  return left.id === right.id && left.boardId === right.boardId && sameDate(left.updatedAt, right.updatedAt);
+}
+function sameTaskSnapshots(left, right) {
+  return left.id === right.id && left.columnId === right.columnId && left.assigneeId === right.assigneeId && left.isArchived === right.isArchived && sameDate(left.updatedAt, right.updatedAt);
+}
+function sameSnapshotSet(current, expected, equal) {
+  if (current.length !== expected.length) return false;
+  const byId = new Map(current.map((value) => [value.id, value]));
+  return expected.every((snapshot) => {
+    const value = byId.get(snapshot.id);
+    return value !== void 0 && equal(value, snapshot);
+  });
+}
+function nextSnapshotDate(previous) {
+  return new Date(Math.max(Date.now(), previous.getTime() + 1));
+}
+const AFFECTED_ROW_KEYS = [
+  "rowCount",
+  "affectedRows",
+  "rowsAffected",
+  "changes",
+  "numUpdatedRows"
+];
+function hasPositiveCount(value) {
+  if (typeof value === "number") return Number.isFinite(value) && value > 0;
+  if (typeof value === "bigint") return value > 0n;
+  return false;
+}
+function didAffectRow(result, expectedId) {
+  if (typeof result === "number" || typeof result === "bigint") {
+    return hasPositiveCount(result);
+  }
+  if (!result || typeof result !== "object") return false;
+  const record = result;
+  if ("count" in record) return hasPositiveCount(record.count);
+  if (Array.isArray(result)) {
+    return result.length > 0 && didAffectRow(result[0], expectedId);
+  }
+  for (const key of AFFECTED_ROW_KEYS) {
+    if (key in record) return hasPositiveCount(record[key]);
+  }
+  if ("meta" in record) {
+    const meta = record.meta;
+    return Boolean(
+      meta && typeof meta === "object" && "changes" in meta && hasPositiveCount(meta.changes)
+    );
+  }
+  return record.id === expectedId;
+}
+const memoryRollbackMarkers = /* @__PURE__ */ new WeakMap();
+function markMemoryRollback(adapter, error) {
+  memoryRollbackMarkers.get(adapter)?.(error);
+}
+function serializeMemoryOperations(adapter) {
+  if (adapter.id !== "memory" || memoryRollbackMarkers.has(adapter)) {
+    return adapter;
+  }
+  const source = { ...adapter };
+  const lockContext = new AsyncLocalStorage();
+  let tail = Promise.resolve();
+  let activeOwner;
+  const withLock = async (run) => {
+    const inherited = lockContext.getStore();
+    if (inherited && inherited.owner === activeOwner) {
+      return run(inherited.adapter);
+    }
+    let release = () => {
+    };
+    const previous = tail;
+    tail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    const owner = {};
+    activeOwner = owner;
+    try {
+      return await lockContext.run(
+        { owner, adapter: source },
+        () => run(source)
+      );
+    } finally {
+      if (activeOwner === owner) activeOwner = void 0;
+      release();
+    }
+  };
+  const serialized = {
+    ...source,
+    create: ((input) => withLock((active) => active.create(input))),
+    findOne: ((input) => withLock((active) => active.findOne(input))),
+    findMany: ((input) => withLock((active) => active.findMany(input))),
+    count: (input) => withLock((active) => active.count(input)),
+    update: ((input) => withLock((active) => active.update(input))),
+    updateMany: (input) => withLock((active) => active.updateMany(input)),
+    delete: ((input) => withLock((active) => active.delete(input))),
+    deleteMany: (input) => withLock((active) => active.deleteMany(input)),
+    consumeOne: ((input) => withLock((active) => active.consumeOne(input))),
+    transaction: ((callback) => withLock((active) => {
+      const context = lockContext.getStore();
+      if (!context) throw new TypeError("Missing memory lock context.");
+      if (context.inTransaction) {
+        return callback(active).catch((error) => {
+          context.rollbackOnly = true;
+          context.rollbackError = error;
+          throw error;
+        });
+      }
+      if (!active.transaction) {
+        throw new TypeError("Missing memory transaction adapter.");
+      }
+      return active.transaction(
+        (tx) => lockContext.run(
+          { owner: context.owner, adapter: tx, inTransaction: true },
+          async () => {
+            const transactionContext = lockContext.getStore();
+            const result = await callback(tx);
+            if (transactionContext?.rollbackOnly) {
+              throw transactionContext.rollbackError;
+            }
+            return result;
+          }
+        )
+      );
+    }))
+  };
+  memoryRollbackMarkers.set(adapter, (error) => {
+    const context = lockContext.getStore();
+    if (!context || context.owner !== activeOwner || !context.inTransaction) {
+      return;
+    }
+    context.rollbackOnly = true;
+    context.rollbackError = error;
+  });
+  Object.assign(adapter, serialized);
+  return adapter;
+}
+function requireAtomicTransactions(adapter) {
+  if (adapter.id !== "memory" && typeof adapter.options?.adapterConfig.transaction !== "function") {
+    throw new KanbanOperationError(
+      500,
+      "Kanban writes require an adapter with isolated transaction support.",
+      "ATOMIC_TRANSACTION_REQUIRED"
+    );
+  }
+}
+function boardWhere(snapshot) {
+  return [
+    { field: "id", value: snapshot.id, operator: "eq" },
+    {
+      field: "ownerId",
+      value: snapshot.ownerId ?? null,
+      operator: "eq"
+    },
+    {
+      field: "organizationId",
+      value: snapshot.organizationId ?? null,
+      operator: "eq"
+    },
+    {
+      field: "updatedAt",
+      value: snapshot.updatedAt,
+      operator: "eq"
+    }
+  ];
+}
+function columnWhere(snapshot) {
+  return [
+    { field: "id", value: snapshot.id, operator: "eq" },
+    { field: "boardId", value: snapshot.boardId, operator: "eq" },
+    {
+      field: "updatedAt",
+      value: snapshot.updatedAt,
+      operator: "eq"
+    }
+  ];
+}
+function taskWhere(snapshot) {
+  return [
+    { field: "id", value: snapshot.id, operator: "eq" },
+    { field: "columnId", value: snapshot.columnId, operator: "eq" },
+    {
+      field: "assigneeId",
+      value: snapshot.assigneeId ?? null,
+      operator: "eq"
+    },
+    {
+      field: "isArchived",
+      value: snapshot.isArchived,
+      operator: "eq"
+    },
+    {
+      field: "updatedAt",
+      value: snapshot.updatedAt,
+      operator: "eq"
+    }
+  ];
+}
+async function claimSnapshot(adapter, model, snapshot) {
+  const claimedAt = nextSnapshotDate(snapshot.updatedAt);
+  const where = model === "kanbanBoard" ? boardWhere(snapshot) : model === "kanbanColumn" ? columnWhere(snapshot) : taskWhere(snapshot);
+  const claimed = await adapter.updateMany({
+    model,
+    where,
+    update: { updatedAt: claimedAt }
+  });
+  if (!didAffectRow(claimed, snapshot.id)) throw staleStateError();
+  return claimedAt;
+}
+async function restoreSnapshot(adapter, model, snapshot, claimedAt) {
+  const where = model === "kanbanBoard" ? boardWhere({ ...snapshot, updatedAt: claimedAt }) : columnWhere({ ...snapshot, updatedAt: claimedAt });
+  const restored = await adapter.updateMany({
+    model,
+    where,
+    update: { updatedAt: snapshot.updatedAt }
+  });
+  if (!didAffectRow(restored, snapshot.id)) throw staleStateError();
+}
+async function findBoard(adapter, id) {
+  return await adapter.findOne({
+    model: "kanbanBoard",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  }) ?? null;
+}
+async function findColumn(adapter, id) {
+  return await adapter.findOne({
+    model: "kanbanColumn",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  }) ?? null;
+}
+async function findTask(adapter, id) {
+  return await adapter.findOne({
+    model: "kanbanTask",
+    where: [{ field: "id", value: id, operator: "eq" }]
+  }) ?? null;
+}
+async function listColumns(adapter, boardId) {
+  return adapter.findMany({
+    model: "kanbanColumn",
+    where: [{ field: "boardId", value: boardId, operator: "eq" }],
+    sortBy: { field: "order", direction: "asc" }
+  });
+}
+async function listTasks(adapter, columnId) {
+  return adapter.findMany({
+    model: "kanbanTask",
+    where: [{ field: "columnId", value: columnId, operator: "eq" }],
+    sortBy: { field: "order", direction: "asc" }
+  });
+}
+function boardNotFoundError() {
+  return new KanbanOperationError(404, "Board not found", "BOARD_NOT_FOUND");
+}
+function columnNotFoundError() {
+  return new KanbanOperationError(404, "Column not found", "COLUMN_NOT_FOUND");
+}
+function taskNotFoundError() {
+  return new KanbanOperationError(404, "Task not found", "TASK_NOT_FOUND");
+}
+function staleStateError() {
+  return new KanbanOperationError(
+    409,
+    "Kanban state changed while authorization was being evaluated. Retry the operation.",
+    "KANBAN_STATE_CHANGED"
+  );
+}
+function invalidColumnSetError() {
+  return new KanbanOperationError(
+    400,
+    "columnIds must contain every current board column exactly once.",
+    "INVALID_COLUMN_SET"
+  );
+}
+function invalidTaskSetError() {
+  return new KanbanOperationError(
+    400,
+    "taskIds must contain every current column task exactly once.",
+    "INVALID_TASK_SET"
+  );
+}
+function invalidTargetColumnError() {
+  return new KanbanOperationError(
+    400,
+    "The target column must belong to the task's board.",
+    "INVALID_TARGET_COLUMN"
+  );
+}
+function sanitizeSlug(value) {
+  const slug = slugify(value);
+  if (!slug) {
+    throw new KanbanOperationError(
+      400,
+      "Invalid slug: must contain at least one alphanumeric character",
+      "INVALID_SLUG"
+    );
+  }
+  return slug;
+}
+function normalizeError(error, fallback) {
+  return error instanceof Error ? error : new Error(typeof error === "string" ? error : fallback, { cause: error });
+}
+async function runDomainHook(run, code) {
+  try {
+    return await run();
+  } catch (error) {
+    throw new KanbanOperationError(
+      403,
+      normalizeError(error, "Kanban operation rejected").message,
+      code
+    );
+  }
+}
+function hookContext(context, legacy = {}) {
+  return Object.freeze({
+    ...context,
+    ...context.request ? { request: context.request, headers: context.request.headers } : {},
+    ...legacy
+  });
+}
+async function notifyBoardError(hook, error, context, legacy = {}) {
+  const normalized = normalizeError(error, "Kanban board operation failed");
+  const lifecycle = hookContext(context, legacy);
+  try {
+    await hook?.(normalized, lifecycle);
+  } catch {
+  }
+}
+function boardFacts(snapshot) {
+  return {
+    boardId: snapshot.id,
+    ...snapshot.ownerId ? { ownerId: snapshot.ownerId } : {},
+    ...snapshot.organizationId ? { organizationId: snapshot.organizationId } : {}
+  };
+}
+function taskFacts(snapshot) {
+  return {
+    ...boardFacts(snapshot.board),
+    columnId: snapshot.column.id,
+    taskId: snapshot.task.id,
+    ...snapshot.task.assigneeId ? { assigneeId: snapshot.task.assigneeId } : {},
+    isArchived: snapshot.task.isArchived
+  };
+}
+async function loadColumnAuthorization(adapter, columnId) {
+  const column = await findColumn(adapter, columnId);
+  if (!column) throw columnNotFoundError();
+  const board = await findBoard(adapter, column.boardId);
+  if (!board) throw boardNotFoundError();
+  return { board: boardSnapshot(board), column: columnSnapshot(column) };
+}
+async function loadTaskAuthorization(adapter, taskId) {
+  const task = await findTask(adapter, taskId);
+  if (!task) throw taskNotFoundError();
+  const parent = await loadColumnAuthorization(adapter, task.columnId);
+  return { ...parent, task: taskSnapshot(task) };
+}
+function sameIdSet(left, right) {
+  return left.length === right.length && new Set(left).size === left.length && left.every((id) => right.includes(id));
+}
+function operationTask(task) {
+  const serialized = serializeTask(task);
+  return { ...serialized };
+}
+function operationColumn(column) {
+  return {
+    ...serializeBareColumn(column),
+    tasks: column.tasks.map(operationTask)
+  };
+}
+function operationBoard(board) {
+  return {
+    ...serializeBareBoard(board),
+    columns: board.columns.map(operationColumn)
+  };
+}
+function boardSummary(board) {
+  return serializeBoardSummary(board);
+}
+function serializeBareColumn(column) {
+  return {
+    ...column,
+    createdAt: column.createdAt.toISOString(),
+    updatedAt: column.updatedAt.toISOString()
+  };
+}
+function serializeBareBoard(board) {
+  return {
+    ...board,
+    createdAt: board.createdAt.toISOString(),
+    updatedAt: board.updatedAt.toISOString()
+  };
+}
+async function verifyBoard(adapter, expected) {
+  if (!sameBoard(await findBoard(adapter, expected.id), expected)) {
+    throw staleStateError();
+  }
+}
+async function verifyColumnAuthorization(adapter, expected) {
+  await verifyBoard(adapter, expected.board);
+  if (!sameColumn(await findColumn(adapter, expected.column.id), expected.column)) {
+    throw staleStateError();
+  }
+}
+async function verifyTaskAuthorization(adapter, expected) {
+  await verifyColumnAuthorization(adapter, expected);
+  if (!sameTask(await findTask(adapter, expected.task.id), expected.task)) {
+    throw staleStateError();
+  }
+}
+async function loadMoveSnapshot(adapter, primary, targetColumnId, targetOrder) {
+  await verifyTaskAuthorization(adapter, primary);
+  const targetColumn = await findColumn(adapter, targetColumnId);
+  if (!targetColumn) throw columnNotFoundError();
+  if (targetColumn.boardId !== primary.board.id) {
+    throw invalidTargetColumnError();
+  }
+  const [sourceTasks, targetTasks] = await Promise.all([
+    listTasks(adapter, primary.column.id),
+    targetColumn.id === primary.column.id ? Promise.resolve([]) : listTasks(adapter, targetColumn.id)
+  ]);
+  return {
+    ...primary,
+    targetColumn: columnSnapshot(targetColumn),
+    sourceTasks: sourceTasks.map(taskSnapshot),
+    targetTasks: targetColumn.id === primary.column.id ? sourceTasks.map(taskSnapshot) : targetTasks.map(taskSnapshot),
+    targetOrder
+  };
+}
+async function verifyMoveSnapshot(adapter, expected) {
+  await verifyTaskAuthorization(adapter, expected);
+  if (!sameColumn(
+    await findColumn(adapter, expected.targetColumn.id),
+    expected.targetColumn
+  )) {
+    throw staleStateError();
+  }
+  const sourceTasks = (await listTasks(adapter, expected.column.id)).map(
+    taskSnapshot
+  );
+  const targetTasks = expected.targetColumn.id === expected.column.id ? sourceTasks : (await listTasks(adapter, expected.targetColumn.id)).map(taskSnapshot);
+  if (!sameSnapshotSet(sourceTasks, expected.sourceTasks, sameTaskSnapshots) || !sameSnapshotSet(targetTasks, expected.targetTasks, sameTaskSnapshots)) {
+    throw staleStateError();
+  }
+}
+async function claimColumnAuthorization(adapter, snapshot) {
+  const boardClaimedAt = await claimSnapshot(
+    adapter,
+    "kanbanBoard",
+    snapshot.board
+  );
+  const columnClaimedAt = await claimSnapshot(
+    adapter,
+    "kanbanColumn",
+    snapshot.column
+  );
+  return { boardClaimedAt, columnClaimedAt };
+}
+async function restoreColumnAuthorization(adapter, snapshot, claims) {
+  await restoreSnapshot(
+    adapter,
+    "kanbanColumn",
+    snapshot.column,
+    claims.columnClaimedAt
+  );
+  await restoreSnapshot(
+    adapter,
+    "kanbanBoard",
+    snapshot.board,
+    claims.boardClaimedAt
+  );
+}
+async function claimMoveSnapshot(adapter, snapshot) {
+  const boardClaimedAt = await claimSnapshot(
+    adapter,
+    "kanbanBoard",
+    snapshot.board
+  );
+  const sourceColumnClaimedAt = await claimSnapshot(
+    adapter,
+    "kanbanColumn",
+    snapshot.column
+  );
+  const targetColumnClaimedAt = snapshot.targetColumn.id === snapshot.column.id ? sourceColumnClaimedAt : await claimSnapshot(adapter, "kanbanColumn", snapshot.targetColumn);
+  const taskClaims = /* @__PURE__ */ new Map();
+  const allTasks = /* @__PURE__ */ new Map();
+  for (const task of [...snapshot.sourceTasks, ...snapshot.targetTasks]) {
+    allTasks.set(task.id, task);
+  }
+  for (const task of allTasks.values()) {
+    taskClaims.set(task.id, await claimSnapshot(adapter, "kanbanTask", task));
+  }
+  return {
+    boardClaimedAt,
+    sourceColumnClaimedAt,
+    targetColumnClaimedAt,
+    taskClaims
+  };
+}
+async function applyTaskMove(adapter, snapshot, claims, extraUpdate) {
+  const sourceTasks = snapshot.sourceTasks.filter(
+    (task) => task.id !== snapshot.task.id
+  );
+  const targetBase = snapshot.targetColumn.id === snapshot.column.id ? sourceTasks : snapshot.targetTasks.filter((task) => task.id !== snapshot.task.id);
+  const targetOrder = Math.min(snapshot.targetOrder, targetBase.length);
+  const orderedTarget = [...targetBase];
+  orderedTarget.splice(targetOrder, 0, {
+    ...snapshot.task,
+    columnId: snapshot.targetColumn.id
+  });
+  const finalRows = /* @__PURE__ */ new Map();
+  if (snapshot.targetColumn.id !== snapshot.column.id) {
+    sourceTasks.forEach((task, order) => {
+      finalRows.set(task.id, {
+        snapshot: task,
+        columnId: task.columnId,
+        order
+      });
+    });
+  }
+  orderedTarget.forEach((task, order) => {
+    const original = task.id === snapshot.task.id ? snapshot.task : snapshot.targetTasks.find((candidate) => candidate.id === task.id) ?? task;
+    finalRows.set(task.id, {
+      snapshot: original,
+      columnId: snapshot.targetColumn.id,
+      order
+    });
+  });
+  let moved = null;
+  for (const row of finalRows.values()) {
+    const claimedAt = claims.taskClaims.get(row.snapshot.id);
+    if (!claimedAt) throw staleStateError();
+    const matched = await adapter.updateMany({
+      model: "kanbanTask",
+      where: taskWhere({ ...row.snapshot, updatedAt: claimedAt }),
+      update: {
+        ...row.snapshot.id === snapshot.task.id ? extraUpdate : {},
+        columnId: row.columnId,
+        order: row.order,
+        updatedAt: nextSnapshotDate(claimedAt)
+      }
+    });
+    if (!didAffectRow(matched, row.snapshot.id)) throw staleStateError();
+    if (row.snapshot.id === snapshot.task.id) {
+      moved = await findTask(adapter, row.snapshot.id);
+    }
+  }
+  if (!moved) throw taskNotFoundError();
+  await restoreSnapshot(
+    adapter,
+    "kanbanColumn",
+    snapshot.column,
+    claims.sourceColumnClaimedAt
+  );
+  if (snapshot.targetColumn.id !== snapshot.column.id) {
+    await restoreSnapshot(
+      adapter,
+      "kanbanColumn",
+      snapshot.targetColumn,
+      claims.targetColumnClaimedAt
+    );
+  }
+  await restoreSnapshot(
+    adapter,
+    "kanbanBoard",
+    snapshot.board,
+    claims.boardClaimedAt
+  );
+  return moved;
+}
+function sameOptionalBoard(board, expected) {
+  return expected === null ? board === null : sameBoard(board, expected);
+}
+function createKanbanOperations(sourceAdapter, hooks) {
+  const adapter = serializeMemoryOperations(sourceAdapter);
+  const boardSnapshots = /* @__PURE__ */ new WeakMap();
+  const columnSnapshots = /* @__PURE__ */ new WeakMap();
+  const taskSnapshots = /* @__PURE__ */ new WeakMap();
+  const columnReorderSnapshots = /* @__PURE__ */ new WeakMap();
+  const taskReorderSnapshots = /* @__PURE__ */ new WeakMap();
+  const taskMoveSnapshots = /* @__PURE__ */ new WeakMap();
+  const updateTaskMoveSnapshots = /* @__PURE__ */ new WeakMap();
+  const reorderedColumns = /* @__PURE__ */ new WeakMap();
+  const reorderedTasks = /* @__PURE__ */ new WeakMap();
+  const listBoards = defineOperation({
+    input: BoardListQuerySchema,
+    permission: kanbanPermissions.board.read,
+    facts: () => ({ scope: "collection" }),
+    before: async (context) => {
+      await runDomainHook(
+        () => hooks?.onBeforeListBoards?.(
+          { ...context.input },
+          hookContext(context, { query: context.input })
+        ),
+        "LIST_BOARDS_REJECTED"
+      );
+    },
+    execute: async ({ input }) => {
+      const result = await getBoardSummaries(adapter, input);
+      return {
+        items: result.items.map(boardSummary),
+        total: result.total,
+        ...result.limit !== void 0 ? { limit: result.limit } : {},
+        ...result.offset !== void 0 ? { offset: result.offset } : {}
+      };
+    },
+    after: async (context) => {
+      await hooks?.onAfterListBoards?.(
+        context.result.items,
+        { ...context.input },
+        hookContext(context, { query: context.input })
+      );
+    },
+    onError: ({ error, ...context }) => notifyBoardError(hooks?.onErrorListBoards, error, context, {
+      query: context.input
+    })
+  });
+  const getBoard = defineOperation({
+    input: BoardIdOperationInputSchema,
+    permission: kanbanPermissions.board.read,
+    facts: async ({ input }) => {
+      const board = await findBoard(adapter, input.id);
+      const snapshot = board ? boardSnapshot(board) : null;
+      boardSnapshots.set(input, snapshot);
+      return {
+        scope: "record",
+        boardId: input.id,
+        exists: snapshot !== null,
+        ...snapshot ? boardFacts(snapshot) : {}
+      };
+    },
+    before: async (context) => {
+      const expected = boardSnapshots.get(context.input) ?? null;
+      if (!sameOptionalBoard(await findBoard(adapter, context.input.id), expected)) {
+        throw staleStateError();
+      }
+      await runDomainHook(
+        () => hooks?.onBeforeGetBoard?.(
+          context.input.id,
+          hookContext(context, { params: { id: context.input.id } })
+        ),
+        "READ_BOARD_REJECTED"
+      );
+    },
+    execute: async (context) => {
+      const expected = boardSnapshots.get(context.input) ?? null;
+      const board = await getBoardById(adapter, context.input.id);
+      if (!sameOptionalBoard(board, expected)) {
+        throw staleStateError();
+      }
+      if (!board) throw boardNotFoundError();
+      return operationBoard(board);
+    },
+    after: async (context) => {
+      await hooks?.onAfterGetBoard?.(
+        context.result,
+        hookContext(context, { params: { id: context.input.id } })
+      );
+    },
+    onError: ({ error, ...context }) => notifyBoardError(hooks?.onErrorGetBoard, error, context, {
+      params: { id: context.input.id }
+    })
+  });
+  const createBoard = defineOperation({
+    input: createBoardSchema,
+    permission: kanbanPermissions.board.create,
+    facts: () => void 0,
+    execute: async (context) => {
+      const data = { ...context.input };
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await runDomainHook(
+          () => hooks?.onBeforeCreateBoard?.(
+            data,
+            hookContext(context, { body: data })
+          ),
+          "CREATE_BOARD_REJECTED"
+        );
+        const input = {
+          ...data,
+          slug: sanitizeSlug(data.slug || data.name),
+          ...context.identity ? { ownerId: context.identity.id } : {}
+        };
+        const now = /* @__PURE__ */ new Date();
+        const board = await tx.create({
+          model: "kanbanBoard",
+          data: {
+            ...input,
+            createdAt: now,
+            updatedAt: now
+          }
+        });
+        const columns = [];
+        for (const [order, title] of [
+          "To Do",
+          "In Progress",
+          "Done"
+        ].entries()) {
+          columns.push(
+            await tx.create({
+              model: "kanbanColumn",
+              data: {
+                title,
+                boardId: board.id,
+                order,
+                createdAt: now,
+                updatedAt: now
+              }
+            })
+          );
+        }
+        return operationBoard({
+          ...board,
+          columns: columns.map((column) => ({ ...column, tasks: [] }))
+        });
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterCreateBoard?.(
+        context.result,
+        hookContext(context, { body: context.input })
+      );
+    },
+    onError: ({ error, ...context }) => {
+      markMemoryRollback(adapter, error);
+      return notifyBoardError(hooks?.onErrorCreateBoard, error, context, {
+        body: context.input
+      });
+    }
+  });
+  const updateBoard = defineOperation({
+    input: UpdateBoardOperationInputSchema,
+    permission: kanbanPermissions.board.update,
+    facts: async ({ input }) => {
+      const board = await findBoard(adapter, input.id);
+      if (!board) throw boardNotFoundError();
+      const snapshot = boardSnapshot(board);
+      boardSnapshots.set(input, snapshot);
+      return boardFacts(snapshot);
+    },
+    execute: async (context) => {
+      const snapshot = boardSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      const data = {
+        ...context.input.data,
+        ...context.input.data.slug ? { slug: sanitizeSlug(context.input.data.slug) } : {}
+      };
+      return adapter.transaction(async (tx) => {
+        await verifyBoard(tx, snapshot);
+        const claimedAt = await claimSnapshot(tx, "kanbanBoard", snapshot);
+        await runDomainHook(
+          () => hooks?.onBeforeUpdateBoard?.(
+            context.input.id,
+            { ...data, id: context.input.id },
+            hookContext(context, {
+              body: data,
+              params: { id: context.input.id }
+            })
+          ),
+          "UPDATE_BOARD_REJECTED"
+        );
+        const matched = await tx.updateMany({
+          model: "kanbanBoard",
+          where: boardWhere({ ...snapshot, updatedAt: claimedAt }),
+          update: {
+            ...data,
+            updatedAt: nextSnapshotDate(claimedAt)
+          }
+        });
+        if (!didAffectRow(matched, snapshot.id)) throw staleStateError();
+        const updated = await findBoard(tx, snapshot.id);
+        if (!updated) throw boardNotFoundError();
+        return serializeBareBoard(updated);
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterUpdateBoard?.(
+        context.result,
+        hookContext(context, {
+          body: context.input.data,
+          params: { id: context.input.id }
+        })
+      );
+    },
+    onError: ({ error, ...context }) => {
+      markMemoryRollback(adapter, error);
+      return notifyBoardError(hooks?.onErrorUpdateBoard, error, context, {
+        body: context.input.data,
+        params: { id: context.input.id }
+      });
+    }
+  });
+  const deleteBoard = defineOperation({
+    input: BoardIdOperationInputSchema,
+    permission: kanbanPermissions.board.delete,
+    facts: async ({ input }) => {
+      const board = await findBoard(adapter, input.id);
+      if (!board) throw boardNotFoundError();
+      const snapshot = boardSnapshot(board);
+      boardSnapshots.set(input, snapshot);
+      return boardFacts(snapshot);
+    },
+    execute: async (context) => {
+      const snapshot = boardSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyBoard(tx, snapshot);
+        const claimedAt = await claimSnapshot(tx, "kanbanBoard", snapshot);
+        await runDomainHook(
+          () => hooks?.onBeforeDeleteBoard?.(
+            context.input.id,
+            hookContext(context, {
+              params: { id: context.input.id }
+            })
+          ),
+          "DELETE_BOARD_REJECTED"
+        );
+        const deleted = await tx.deleteMany({
+          model: "kanbanBoard",
+          where: boardWhere({ ...snapshot, updatedAt: claimedAt })
+        });
+        if (!didAffectRow(deleted, snapshot.id)) throw staleStateError();
+        return { success: true };
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterDeleteBoard?.(
+        context.input.id,
+        hookContext(context, { params: { id: context.input.id } })
+      );
+    },
+    onError: ({ error, ...context }) => {
+      markMemoryRollback(adapter, error);
+      return notifyBoardError(hooks?.onErrorDeleteBoard, error, context, {
+        params: { id: context.input.id }
+      });
+    }
+  });
+  const createColumn = defineOperation({
+    input: createColumnSchema,
+    permission: kanbanPermissions.column.create,
+    facts: async ({ input }) => {
+      const board = await findBoard(adapter, input.boardId);
+      if (!board) throw boardNotFoundError();
+      const snapshot = boardSnapshot(board);
+      boardSnapshots.set(input, snapshot);
+      return boardFacts(snapshot);
+    },
+    execute: async (context) => {
+      const board = boardSnapshots.get(context.input);
+      if (!board) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyBoard(tx, board);
+        const boardClaimedAt = await claimSnapshot(tx, "kanbanBoard", board);
+        await runDomainHook(
+          () => hooks?.onBeforeCreateColumn?.(
+            { ...context.input },
+            hookContext(context, { body: context.input })
+          ),
+          "CREATE_COLUMN_REJECTED"
+        );
+        const existing = await listColumns(tx, board.id);
+        const nextOrder = existing.length === 0 ? 0 : Math.max(...existing.map((column2) => column2.order)) + 1;
+        const now = /* @__PURE__ */ new Date();
+        const column = await tx.create({
+          model: "kanbanColumn",
+          data: {
+            ...context.input,
+            order: context.input.order ?? nextOrder,
+            createdAt: now,
+            updatedAt: now
+          }
+        });
+        await restoreSnapshot(tx, "kanbanBoard", board, boardClaimedAt);
+        return serializeBareColumn(column);
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterCreateColumn?.(
+        context.result,
+        hookContext(context, { body: context.input })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const updateColumn = defineOperation({
+    input: UpdateColumnOperationInputSchema,
+    permission: kanbanPermissions.column.update,
+    facts: async ({ input }) => {
+      const snapshot = await loadColumnAuthorization(adapter, input.id);
+      columnSnapshots.set(input, snapshot);
+      return {
+        ...boardFacts(snapshot.board),
+        columnId: snapshot.column.id
+      };
+    },
+    additionalPermissions: ({ input }) => {
+      if (input.data.order === void 0) return [];
+      const snapshot = columnSnapshots.get(input);
+      if (!snapshot) throw staleStateError();
+      return [kanbanPermissions.column.reorder(boardFacts(snapshot.board))];
+    },
+    execute: async (context) => {
+      const snapshot = columnSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      if (context.input.data.boardId && context.input.data.boardId !== snapshot.board.id) {
+        throw invalidTargetColumnError();
+      }
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyColumnAuthorization(tx, snapshot);
+        const claims = await claimColumnAuthorization(tx, snapshot);
+        await runDomainHook(
+          () => hooks?.onBeforeUpdateColumn?.(
+            context.input.id,
+            { ...context.input.data, id: context.input.id },
+            hookContext(context, {
+              body: context.input.data,
+              params: { id: context.input.id }
+            })
+          ),
+          "UPDATE_COLUMN_REJECTED"
+        );
+        const matched = await tx.updateMany({
+          model: "kanbanColumn",
+          where: columnWhere({
+            ...snapshot.column,
+            updatedAt: claims.columnClaimedAt
+          }),
+          update: {
+            ...context.input.data,
+            boardId: snapshot.board.id,
+            updatedAt: nextSnapshotDate(claims.columnClaimedAt)
+          }
+        });
+        if (!didAffectRow(matched, snapshot.column.id)) {
+          throw staleStateError();
+        }
+        await restoreSnapshot(
+          tx,
+          "kanbanBoard",
+          snapshot.board,
+          claims.boardClaimedAt
+        );
+        const updated = await findColumn(tx, snapshot.column.id);
+        if (!updated) throw columnNotFoundError();
+        return serializeBareColumn(updated);
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterUpdateColumn?.(
+        context.result,
+        hookContext(context, {
+          body: context.input.data,
+          params: { id: context.input.id }
+        })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const deleteColumn = defineOperation({
+    input: ColumnIdOperationInputSchema,
+    permission: kanbanPermissions.column.delete,
+    facts: async ({ input }) => {
+      const snapshot = await loadColumnAuthorization(adapter, input.id);
+      columnSnapshots.set(input, snapshot);
+      return {
+        ...boardFacts(snapshot.board),
+        columnId: snapshot.column.id
+      };
+    },
+    execute: async (context) => {
+      const snapshot = columnSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyColumnAuthorization(tx, snapshot);
+        const claims = await claimColumnAuthorization(tx, snapshot);
+        await runDomainHook(
+          () => hooks?.onBeforeDeleteColumn?.(
+            context.input.id,
+            hookContext(context, {
+              params: { id: context.input.id }
+            })
+          ),
+          "DELETE_COLUMN_REJECTED"
+        );
+        const deleted = await tx.deleteMany({
+          model: "kanbanColumn",
+          where: columnWhere({
+            ...snapshot.column,
+            updatedAt: claims.columnClaimedAt
+          })
+        });
+        if (!didAffectRow(deleted, snapshot.column.id)) {
+          throw staleStateError();
+        }
+        await restoreSnapshot(
+          tx,
+          "kanbanBoard",
+          snapshot.board,
+          claims.boardClaimedAt
+        );
+        return { success: true };
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterDeleteColumn?.(
+        context.input.id,
+        hookContext(context, { params: { id: context.input.id } })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const reorderColumns = defineOperation({
+    input: reorderColumnsSchema,
+    permission: kanbanPermissions.column.reorder,
+    facts: async ({ input }) => {
+      const board = await findBoard(adapter, input.boardId);
+      if (!board) throw boardNotFoundError();
+      const columns = await listColumns(adapter, board.id);
+      if (!sameIdSet(
+        input.columnIds,
+        columns.map((column) => column.id)
+      )) {
+        throw invalidColumnSetError();
+      }
+      const snapshot = {
+        board: boardSnapshot(board),
+        columns: columns.map(columnSnapshot)
+      };
+      columnReorderSnapshots.set(input, snapshot);
+      return boardFacts(snapshot.board);
+    },
+    execute: async (context) => {
+      const snapshot = columnReorderSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyBoard(tx, snapshot.board);
+        const current = (await listColumns(tx, snapshot.board.id)).map(
+          columnSnapshot
+        );
+        if (!sameSnapshotSet(current, snapshot.columns, sameColumnSnapshots)) {
+          throw staleStateError();
+        }
+        const boardClaimedAt = await claimSnapshot(
+          tx,
+          "kanbanBoard",
+          snapshot.board
+        );
+        const claims = /* @__PURE__ */ new Map();
+        for (const column of snapshot.columns) {
+          claims.set(
+            column.id,
+            await claimSnapshot(tx, "kanbanColumn", column)
+          );
+        }
+        for (const [order, columnId] of context.input.columnIds.entries()) {
+          await runDomainHook(
+            () => hooks?.onBeforeUpdateColumn?.(
+              columnId,
+              { id: columnId, order },
+              hookContext(context, { body: context.input })
+            ),
+            "REORDER_COLUMNS_REJECTED"
+          );
+        }
+        const updated = [];
+        for (const [order, columnId] of context.input.columnIds.entries()) {
+          const original = snapshot.columns.find(
+            (column2) => column2.id === columnId
+          );
+          const claimedAt = claims.get(columnId);
+          if (!original || !claimedAt) throw staleStateError();
+          const matched = await tx.updateMany({
+            model: "kanbanColumn",
+            where: columnWhere({ ...original, updatedAt: claimedAt }),
+            update: { order, updatedAt: nextSnapshotDate(claimedAt) }
+          });
+          if (!didAffectRow(matched, columnId)) throw staleStateError();
+          const column = await findColumn(tx, columnId);
+          if (!column) throw columnNotFoundError();
+          updated.push(serializeBareColumn(column));
+        }
+        await restoreSnapshot(
+          tx,
+          "kanbanBoard",
+          snapshot.board,
+          boardClaimedAt
+        );
+        const result = { success: true };
+        reorderedColumns.set(result, updated);
+        return result;
+      });
+    },
+    after: async (context) => {
+      for (const column of reorderedColumns.get(context.result) ?? []) {
+        await hooks?.onAfterUpdateColumn?.(
+          column,
+          hookContext(context, { body: context.input })
+        );
+      }
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const createTask = defineOperation({
+    input: createTaskSchema,
+    permission: kanbanPermissions.task.create,
+    facts: async ({ input }) => {
+      const snapshot = await loadColumnAuthorization(adapter, input.columnId);
+      columnSnapshots.set(input, snapshot);
+      return {
+        ...boardFacts(snapshot.board),
+        columnId: snapshot.column.id
+      };
+    },
+    execute: async (context) => {
+      const snapshot = columnSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyColumnAuthorization(tx, snapshot);
+        const claims = await claimColumnAuthorization(tx, snapshot);
+        await runDomainHook(
+          () => hooks?.onBeforeCreateTask?.(
+            { ...context.input },
+            hookContext(context, { body: context.input })
+          ),
+          "CREATE_TASK_REJECTED"
+        );
+        const existing = await listTasks(tx, snapshot.column.id);
+        const nextOrder = existing.length === 0 ? 0 : Math.max(...existing.map((task2) => task2.order)) + 1;
+        const now = /* @__PURE__ */ new Date();
+        const { completedAt, ...persistenceInput } = context.input;
+        const task = await tx.create({
+          model: "kanbanTask",
+          data: {
+            ...persistenceInput,
+            priority: context.input.priority ?? "MEDIUM",
+            order: context.input.order ?? nextOrder,
+            assigneeId: context.input.assigneeId ?? void 0,
+            isArchived: context.input.isArchived ?? false,
+            ...completedAt ? { completedAt: new Date(completedAt) } : {},
+            createdAt: now,
+            updatedAt: now
+          }
+        });
+        await restoreColumnAuthorization(tx, snapshot, claims);
+        return operationTask(task);
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterCreateTask?.(
+        context.result,
+        hookContext(context, { body: context.input })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const updateTask = defineOperation({
+    input: UpdateTaskOperationInputSchema,
+    permission: kanbanPermissions.task.update,
+    facts: async ({ input }) => {
+      const snapshot = await loadTaskAuthorization(adapter, input.id);
+      taskSnapshots.set(input, snapshot);
+      return taskFacts(snapshot);
+    },
+    additionalPermissions: async ({ input }) => {
+      const snapshot = taskSnapshots.get(input);
+      if (!snapshot) throw staleStateError();
+      const targetColumnId = input.data.columnId ?? snapshot.column.id;
+      const changesColumn = targetColumnId !== snapshot.column.id;
+      const changesOrder = input.data.order !== void 0;
+      if (!changesColumn && !changesOrder) return [];
+      const moveSnapshot = await loadMoveSnapshot(
+        adapter,
+        snapshot,
+        targetColumnId,
+        input.data.order ?? Number.MAX_SAFE_INTEGER
+      );
+      updateTaskMoveSnapshots.set(input, moveSnapshot);
+      return [
+        kanbanPermissions.task.move({
+          ...taskFacts(moveSnapshot),
+          targetColumnId: moveSnapshot.targetColumn.id
+        })
+      ];
+    },
+    execute: async (context) => {
+      const snapshot = taskSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      const {
+        columnId: _columnId,
+        order: _order,
+        completedAt,
+        ...operationTaskData
+      } = context.input.data;
+      const taskData = {
+        ...operationTaskData,
+        ...completedAt ? { completedAt: new Date(completedAt) } : {}
+      };
+      const moveSnapshot = updateTaskMoveSnapshots.get(context.input);
+      if (moveSnapshot) {
+        return adapter.transaction(async (tx) => {
+          await verifyMoveSnapshot(tx, moveSnapshot);
+          const claims = await claimMoveSnapshot(tx, moveSnapshot);
+          await runDomainHook(
+            () => hooks?.onBeforeUpdateTask?.(
+              context.input.id,
+              { ...context.input.data, id: context.input.id },
+              hookContext(context, {
+                body: context.input.data,
+                params: { id: context.input.id }
+              })
+            ),
+            "UPDATE_TASK_REJECTED"
+          );
+          return operationTask(
+            await applyTaskMove(tx, moveSnapshot, claims, taskData)
+          );
+        });
+      }
+      return adapter.transaction(async (tx) => {
+        await verifyTaskAuthorization(tx, snapshot);
+        const claims = await claimColumnAuthorization(tx, snapshot);
+        const taskClaimedAt = await claimSnapshot(
+          tx,
+          "kanbanTask",
+          snapshot.task
+        );
+        await runDomainHook(
+          () => hooks?.onBeforeUpdateTask?.(
+            context.input.id,
+            { ...context.input.data, id: context.input.id },
+            hookContext(context, {
+              body: context.input.data,
+              params: { id: context.input.id }
+            })
+          ),
+          "UPDATE_TASK_REJECTED"
+        );
+        const matched = await tx.updateMany({
+          model: "kanbanTask",
+          where: taskWhere({
+            ...snapshot.task,
+            updatedAt: taskClaimedAt
+          }),
+          update: {
+            ...taskData,
+            updatedAt: nextSnapshotDate(taskClaimedAt)
+          }
+        });
+        if (!didAffectRow(matched, snapshot.task.id)) {
+          throw staleStateError();
+        }
+        await restoreColumnAuthorization(tx, snapshot, claims);
+        const updated = await findTask(tx, snapshot.task.id);
+        if (!updated) throw taskNotFoundError();
+        return operationTask(updated);
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterUpdateTask?.(
+        context.result,
+        hookContext(context, {
+          body: context.input.data,
+          params: { id: context.input.id }
+        })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const deleteTask = defineOperation({
+    input: TaskIdOperationInputSchema,
+    permission: kanbanPermissions.task.delete,
+    facts: async ({ input }) => {
+      const snapshot = await loadTaskAuthorization(adapter, input.id);
+      taskSnapshots.set(input, snapshot);
+      return taskFacts(snapshot);
+    },
+    execute: async (context) => {
+      const snapshot = taskSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyTaskAuthorization(tx, snapshot);
+        const claims = await claimColumnAuthorization(tx, snapshot);
+        const taskClaimedAt = await claimSnapshot(
+          tx,
+          "kanbanTask",
+          snapshot.task
+        );
+        await runDomainHook(
+          () => hooks?.onBeforeDeleteTask?.(
+            context.input.id,
+            hookContext(context, {
+              params: { id: context.input.id }
+            })
+          ),
+          "DELETE_TASK_REJECTED"
+        );
+        const deleted = await tx.deleteMany({
+          model: "kanbanTask",
+          where: taskWhere({
+            ...snapshot.task,
+            updatedAt: taskClaimedAt
+          })
+        });
+        if (!didAffectRow(deleted, snapshot.task.id)) {
+          throw staleStateError();
+        }
+        await restoreColumnAuthorization(tx, snapshot, claims);
+        return { success: true };
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterDeleteTask?.(
+        context.input.id,
+        hookContext(context, { params: { id: context.input.id } })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const moveTask = defineOperation({
+    input: moveTaskSchema,
+    permission: kanbanPermissions.task.move,
+    facts: async ({ input }) => {
+      const primary = await loadTaskAuthorization(adapter, input.taskId);
+      const snapshot = await loadMoveSnapshot(
+        adapter,
+        primary,
+        input.targetColumnId,
+        input.targetOrder
+      );
+      taskMoveSnapshots.set(input, snapshot);
+      return {
+        ...taskFacts(snapshot),
+        targetColumnId: snapshot.targetColumn.id
+      };
+    },
+    execute: async (context) => {
+      const snapshot = taskMoveSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyMoveSnapshot(tx, snapshot);
+        const claims = await claimMoveSnapshot(tx, snapshot);
+        await runDomainHook(
+          () => hooks?.onBeforeUpdateTask?.(
+            context.input.taskId,
+            {
+              id: context.input.taskId,
+              columnId: context.input.targetColumnId,
+              order: context.input.targetOrder
+            },
+            hookContext(context, { body: context.input })
+          ),
+          "MOVE_TASK_REJECTED"
+        );
+        return operationTask(await applyTaskMove(tx, snapshot, claims, {}));
+      });
+    },
+    after: async (context) => {
+      await hooks?.onAfterUpdateTask?.(
+        context.result,
+        hookContext(context, { body: context.input })
+      );
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  const reorderTasks = defineOperation({
+    input: reorderTasksSchema,
+    permission: kanbanPermissions.task.reorder,
+    facts: async ({ input }) => {
+      const parent = await loadColumnAuthorization(adapter, input.columnId);
+      const tasks = await listTasks(adapter, input.columnId);
+      if (!sameIdSet(
+        input.taskIds,
+        tasks.map((task) => task.id)
+      )) {
+        throw invalidTaskSetError();
+      }
+      const snapshot = { ...parent, tasks: tasks.map(taskSnapshot) };
+      taskReorderSnapshots.set(input, snapshot);
+      return {
+        ...boardFacts(parent.board),
+        columnId: parent.column.id
+      };
+    },
+    execute: async (context) => {
+      const snapshot = taskReorderSnapshots.get(context.input);
+      if (!snapshot) throw staleStateError();
+      requireAtomicTransactions(adapter);
+      return adapter.transaction(async (tx) => {
+        await verifyColumnAuthorization(tx, snapshot);
+        const current = (await listTasks(tx, snapshot.column.id)).map(
+          taskSnapshot
+        );
+        if (!sameSnapshotSet(current, snapshot.tasks, sameTaskSnapshots)) {
+          throw staleStateError();
+        }
+        const parentClaims = await claimColumnAuthorization(tx, snapshot);
+        const taskClaims = /* @__PURE__ */ new Map();
+        for (const task of snapshot.tasks) {
+          taskClaims.set(task.id, await claimSnapshot(tx, "kanbanTask", task));
+        }
+        for (const [order, taskId] of context.input.taskIds.entries()) {
+          await runDomainHook(
+            () => hooks?.onBeforeUpdateTask?.(
+              taskId,
+              { id: taskId, order },
+              hookContext(context, { body: context.input })
+            ),
+            "REORDER_TASKS_REJECTED"
+          );
+        }
+        const updated = [];
+        for (const [order, taskId] of context.input.taskIds.entries()) {
+          const original = snapshot.tasks.find((task2) => task2.id === taskId);
+          const claimedAt = taskClaims.get(taskId);
+          if (!original || !claimedAt) throw staleStateError();
+          const matched = await tx.updateMany({
+            model: "kanbanTask",
+            where: taskWhere({ ...original, updatedAt: claimedAt }),
+            update: { order, updatedAt: nextSnapshotDate(claimedAt) }
+          });
+          if (!didAffectRow(matched, taskId)) throw staleStateError();
+          const task = await findTask(tx, taskId);
+          if (!task) throw taskNotFoundError();
+          updated.push(operationTask(task));
+        }
+        await restoreColumnAuthorization(tx, snapshot, parentClaims);
+        const result = { success: true };
+        reorderedTasks.set(result, updated);
+        return result;
+      });
+    },
+    after: async (context) => {
+      for (const task of reorderedTasks.get(context.result) ?? []) {
+        await hooks?.onAfterUpdateTask?.(
+          task,
+          hookContext(context, { body: context.input })
+        );
+      }
+    },
+    onError: ({ error }) => markMemoryRollback(adapter, error)
+  });
+  return {
+    listBoards,
+    getBoard,
+    createBoard,
+    updateBoard,
+    deleteBoard,
+    createColumn,
+    updateColumn,
+    deleteColumn,
+    reorderColumns,
+    createTask,
+    updateTask,
+    deleteTask,
+    moveTask,
+    reorderTasks
+  };
+}
+
+export { BoardIdOperationInputSchema, ColumnIdOperationInputSchema, KanbanOperationError, TaskIdOperationInputSchema, UpdateBoardOperationInputSchema, UpdateColumnOperationInputSchema, UpdateTaskOperationInputSchema, createKanbanOperations };