@btst/stack 5.1.0 → 6.0.0-beta.0

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

@@ -1,1552 +0,0 @@
-'use strict';
-
-const node_async_hooks = require('node:async_hooks');
-const api = require('@btst/stack/plugins/api');
-const z = require('zod');
-const plugins_kanban_permissions = require('../../../../../../plugins/kanban/permissions.cjs');
-const schemas = require('../schemas.cjs');
-const utils = require('../utils.cjs');
-const getters = require('./getters.cjs');
-const serializers = require('./serializers.cjs');
-
-const BoardIdOperationInputSchema = z.z.object({ id: z.z.string() });
-const UpdateBoardOperationInputSchema = z.z.object({
-  id: z.z.string(),
-  data: schemas.updateBoardSchema.omit({ id: true })
-});
-const ColumnIdOperationInputSchema = z.z.object({ id: z.z.string() });
-const UpdateColumnOperationInputSchema = z.z.object({
-  id: z.z.string(),
-  data: schemas.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.z.object({ id: z.z.string() });
-const UpdateTaskOperationInputSchema = z.z.object({
-  id: z.z.string(),
-  data: schemas.updateTaskSchema.omit({ id: true })
-});
-class KanbanOperationError extends api.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 node_async_hooks.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 = utils.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 = serializers.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 serializers.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 = api.defineOperation({
-    input: schemas.BoardListQuerySchema,
-    permission: plugins_kanban_permissions.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 getters.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 = api.defineOperation({
-    input: BoardIdOperationInputSchema,
-    permission: plugins_kanban_permissions.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 getters.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 = api.defineOperation({
-    input: schemas.createBoardSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: UpdateBoardOperationInputSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: BoardIdOperationInputSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: schemas.createColumnSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: UpdateColumnOperationInputSchema,
-    permission: plugins_kanban_permissions.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 [plugins_kanban_permissions.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 = api.defineOperation({
-    input: ColumnIdOperationInputSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: schemas.reorderColumnsSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: schemas.createTaskSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: UpdateTaskOperationInputSchema,
-    permission: plugins_kanban_permissions.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 [
-        plugins_kanban_permissions.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 = api.defineOperation({
-    input: TaskIdOperationInputSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: schemas.moveTaskSchema,
-    permission: plugins_kanban_permissions.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 = api.defineOperation({
-    input: schemas.reorderTasksSchema,
-    permission: plugins_kanban_permissions.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
-  };
-}
-
-exports.BoardIdOperationInputSchema = BoardIdOperationInputSchema;
-exports.ColumnIdOperationInputSchema = ColumnIdOperationInputSchema;
-exports.KanbanOperationError = KanbanOperationError;
-exports.TaskIdOperationInputSchema = TaskIdOperationInputSchema;
-exports.UpdateBoardOperationInputSchema = UpdateBoardOperationInputSchema;
-exports.UpdateColumnOperationInputSchema = UpdateColumnOperationInputSchema;
-exports.UpdateTaskOperationInputSchema = UpdateTaskOperationInputSchema;
-exports.createKanbanOperations = createKanbanOperations;