@cat-factory/app 0.153.3 → 0.153.4

package/app/stores/auth/mothership.ts

@@ -0,0 +1,108 @@
+import type { Ref } from 'vue'
+import type { LocalModeConfig } from '@cat-factory/contracts'
+import type { AuthUser } from '~/types/domain'
+
+/**
+ * Shared reactive state + injected dependencies the auth-store redirect factory closes over.
+ * Created once in the `auth` store setup and threaded into {@link createAuthRedirectActions} so
+ * the split operations stay behaviourally identical to the original single-closure store — a
+ * size-only extraction mirroring `stores/board/` and `stores/pipelines/`, not a new seam.
+ */
+export interface AuthRedirectContext {
+  api: ReturnType<typeof useApi>
+  token: Ref<string | null>
+  localMode: Ref<LocalModeConfig | null>
+  mothershipError: Ref<string | null>
+  /** Apply a freshly-minted token + user (the session factory's setter). */
+  applySession: (result: { token: string; user: AuthUser }) => void
+}
+
+/**
+ * The URL-fragment / redirect handling the boot handshake runs before it resolves a session:
+ * capturing a token handed back by our OWN backend's OAuth round-trip, and — in mothership
+ * mode — exchanging a returning MOTHERSHIP session for a local one.
+ */
+export function createAuthRedirectActions(ctx: AuthRedirectContext) {
+  const { api, token, localMode, mothershipError, applySession } = ctx
+
+  /** Pull a token handed back in the post-login URL fragment (#token=…). */
+  function consumeRedirectToken() {
+    if (typeof window === 'undefined') return
+    const match = /(?:^#|[#&])token=([^&]+)/.exec(window.location.hash)
+    if (!match) return
+    token.value = decodeURIComponent(match[1]!)
+    // Strip the token from the URL so it isn't left in history or shared.
+    history.replaceState(null, '', window.location.pathname + window.location.search)
+  }
+
+  /**
+   * Mothership mode: when the mothership OAuth redirect returns here (flagged
+   * `?mothership_connect=1`), the URL fragment carries a MOTHERSHIP session — not a local one.
+   * Hand it to our OWN node, which exchanges it for a cached machine token and returns a LOCAL
+   * session for the same user. Returns true when it handled the redirect (so the caller skips
+   * the normal `consumeRedirectToken`, which would wrongly store the mothership session locally).
+   */
+  async function maybeConnectMothership(): Promise<boolean> {
+    if (typeof window === 'undefined') return false
+    const params = new URLSearchParams(window.location.search)
+    if (params.get('mothership_connect') !== '1') return false
+    const match = /(?:^#|[#&])token=([^&]+)/.exec(window.location.hash)
+    const session = match ? decodeURIComponent(match[1]!) : null
+    // Clean the flag + fragment from the URL regardless of outcome, so it isn't left in history.
+    params.delete('mothership_connect')
+    const qs = params.toString()
+    history.replaceState(null, '', window.location.pathname + (qs ? `?${qs}` : ''))
+    if (!session) return true
+    try {
+      const result = await api.connectMothership(session)
+      applySession({ token: result.session, user: result.user })
+      mothershipError.value = null
+    } catch (err) {
+      // Surface the failure so the login screen shows it, rather than silently dropping the
+      // user back on the sign-in button as if the click did nothing. The captured session is
+      // already stripped from the URL, so recovery is a fresh "Sign in via mothership".
+      mothershipError.value =
+        err instanceof Error ? err.message : 'Could not connect to the mothership'
+    }
+    return true
+  }
+
+  /**
+   * Mothership mode: sign in through the hosted mothership. The mothership owns identity + the
+   * allowlist, so we send the browser to ITS OAuth and return here flagged for the connect
+   * exchange ({@link maybeConnectMothership}). No-op if the mothership URL isn't known.
+   */
+  function signInViaMothership() {
+    if (typeof window === 'undefined') return
+    const base = localMode.value?.mothershipUrl
+    if (!base) return
+    mothershipError.value = null
+    const here = new URL(window.location.origin + window.location.pathname)
+    here.searchParams.set('mothership_connect', '1')
+    const redirect = new URLSearchParams({ redirect: here.toString() })
+    window.location.href = `${base.replace(/\/$/, '')}/auth/login?${redirect}`
+  }
+
+  /** Redeem an `?invite=` token in the URL for the signed-in user, then clean the URL. */
+  async function maybeAcceptInvite() {
+    if (typeof window === 'undefined') return
+    const params = new URLSearchParams(window.location.search)
+    const inviteToken = params.get('invite')
+    if (!inviteToken) return
+    try {
+      await api.acceptInvite(inviteToken)
+    } catch {
+      // Stale/already-accepted invite — ignore and let the app load normally.
+    }
+    params.delete('invite')
+    const qs = params.toString()
+    history.replaceState(null, '', window.location.pathname + (qs ? `?${qs}` : ''))
+  }
+
+  return {
+    consumeRedirectToken,
+    maybeConnectMothership,
+    signInViaMothership,
+    maybeAcceptInvite,
+  }
+}

package/app/stores/auth/session.ts

@@ -0,0 +1,118 @@
+import type { Ref } from 'vue'
+import type { AuthUser } from '~/types/domain'
+
+/**
+ * Shared reactive state + injected dependencies the auth-store sign-in factory closes over.
+ * Created once in the `auth` store setup and threaded into {@link createAuthSessionActions} so
+ * the split operations stay behaviourally identical to the original single-closure store — a
+ * size-only extraction mirroring `stores/board/` and `stores/pipelines/`, not a new seam.
+ */
+export interface AuthSessionContext {
+  api: ReturnType<typeof useApi>
+  /** The backend's base URL, for the browser-navigating OAuth entry points. */
+  apiBase: string
+  token: Ref<string | null>
+  user: Ref<AuthUser | null>
+  autoLoginProvider: Ref<'github' | 'gitlab' | null>
+}
+
+/**
+ * The sign-in / sign-out operations: the browser-navigating OAuth entry points, the
+ * email-password + PAT credential flows, and the session teardown paths (explicit logout vs the
+ * API client's 401 handler, which differ in whether they forget the remembered PAT provider).
+ */
+export function createAuthSessionActions(ctx: AuthSessionContext) {
+  const { api, apiBase, token, user, autoLoginProvider } = ctx
+
+  /** Build a post-login redirect back to the current page, with an optional invite. */
+  function redirectTarget(invite?: string): string {
+    const here = window.location.origin + window.location.pathname
+    const params = new URLSearchParams({ redirect: here })
+    if (invite) params.set('invite', invite)
+    return params.toString()
+  }
+
+  /** Send the browser to the backend's GitHub login, returning here after. */
+  function login(invite?: string) {
+    if (typeof window === 'undefined') return
+    window.location.href = `${apiBase}/auth/login?${redirectTarget(invite)}`
+  }
+
+  /** Send the browser to the backend's Google login, returning here after. */
+  function loginWithGoogle(invite?: string) {
+    if (typeof window === 'undefined') return
+    window.location.href = `${apiBase}/auth/google/login?${redirectTarget(invite)}`
+  }
+
+  /** Apply a freshly-minted token + user (from password signup/login). */
+  function applySession(result: { token: string; user: AuthUser }) {
+    token.value = result.token
+    user.value = result.user
+  }
+
+  /** Register a new email/password user (optionally redeeming an invite). */
+  async function signup(body: { email: string; password: string; name?: string; invite?: string }) {
+    applySession(await api.signup(body))
+  }
+
+  /** Sign in with email/password. */
+  async function passwordLogin(body: { email: string; password: string }) {
+    applySession(await api.passwordLogin(body))
+  }
+
+  /**
+   * Local mode: sign in as the account a source-control PAT belongs to. `token` omitted
+   * uses the server-configured PAT (one-click); otherwise a pasted token. Resolves to the
+   * SAME canonical user as GitHub OAuth would (keyed on the provider's numeric id).
+   */
+  async function patLogin(body: { provider: 'github' | 'gitlab'; token?: string }) {
+    applySession(await api.patLogin(body))
+    // Remember the choice so a later load re-mints the session from the env PAT silently.
+    autoLoginProvider.value = body.provider
+  }
+
+  /** Request a password-reset link by email (always resolves; never reveals existence). */
+  async function forgotPassword(email: string) {
+    await api.forgotPassword({ email })
+  }
+
+  /** Redeem a reset token and set a new password. Throws on an invalid/expired token. */
+  async function resetPassword(token: string, password: string) {
+    await api.resetPassword({ token, password })
+  }
+
+  /** Drop the local session (sessions are stateless server-side). */
+  function logout() {
+    api.logout().catch(() => {})
+    token.value = null
+    user.value = null
+    // Forget the remembered provider so logout sticks (otherwise bootstrap would
+    // immediately re-mint a session from the env PAT).
+    autoLoginProvider.value = null
+  }
+
+  /**
+   * Called by the API client when a request comes back 401. Drops the dead session but KEEPS
+   * the remembered provider (unlike logout): a 401 from an expired/rotated token or a
+   * transient blip should let the next load silently re-mint from the env PAT, not force the
+   * login screen. The guarded re-mint in `bootstrap` clears the choice itself if it genuinely
+   * fails (PAT removed/revoked), so there's no re-login loop.
+   */
+  function handleUnauthorized() {
+    token.value = null
+    user.value = null
+  }
+
+  return {
+    applySession,
+    login,
+    loginWithGoogle,
+    signup,
+    passwordLogin,
+    patLogin,
+    forgotPassword,
+    resetPassword,
+    logout,
+    handleUnauthorized,
+  }
+}

package/app/stores/auth.ts

@@ -7,6 +7,8 @@ import { defineStore } from 'pinia'
 import { computed, ref } from 'vue'
 import type { AuthUser } from '~/types/domain'
 import { retryWhileBackendUnreachable } from '~/utils/backendReady'
+import { createAuthSessionActions } from '~/stores/auth/session'
+import { createAuthRedirectActions } from '~/stores/auth/mothership'
 
 /**
  * "Login with GitHub" session state. The backend mints a signed session token
@@ -121,63 +123,19 @@ export const useAuthStore = defineStore(
       return true
     })
 
-    /** Pull a token handed back in the post-login URL fragment (#token=…). */
-    function consumeRedirectToken() {
-      if (typeof window === 'undefined') return
-      const match = /(?:^#|[#&])token=([^&]+)/.exec(window.location.hash)
-      if (!match) return
-      token.value = decodeURIComponent(match[1]!)
-      // Strip the token from the URL so it isn't left in history or shared.
-      history.replaceState(null, '', window.location.pathname + window.location.search)
-    }
-
-    /**
-     * Mothership mode: when the mothership OAuth redirect returns here (flagged
-     * `?mothership_connect=1`), the URL fragment carries a MOTHERSHIP session — not a local one.
-     * Hand it to our OWN node, which exchanges it for a cached machine token and returns a LOCAL
-     * session for the same user. Returns true when it handled the redirect (so the caller skips
-     * the normal `consumeRedirectToken`, which would wrongly store the mothership session locally).
-     */
-    async function maybeConnectMothership(): Promise<boolean> {
-      if (typeof window === 'undefined') return false
-      const params = new URLSearchParams(window.location.search)
-      if (params.get('mothership_connect') !== '1') return false
-      const match = /(?:^#|[#&])token=([^&]+)/.exec(window.location.hash)
-      const session = match ? decodeURIComponent(match[1]!) : null
-      // Clean the flag + fragment from the URL regardless of outcome, so it isn't left in history.
-      params.delete('mothership_connect')
-      const qs = params.toString()
-      history.replaceState(null, '', window.location.pathname + (qs ? `?${qs}` : ''))
-      if (!session) return true
-      try {
-        const result = await api.connectMothership(session)
-        applySession({ token: result.session, user: result.user })
-        mothershipError.value = null
-      } catch (err) {
-        // Surface the failure so the login screen shows it, rather than silently dropping the
-        // user back on the sign-in button as if the click did nothing. The captured session is
-        // already stripped from the URL, so recovery is a fresh "Sign in via mothership".
-        mothershipError.value =
-          err instanceof Error ? err.message : 'Could not connect to the mothership'
-      }
-      return true
-    }
-
-    /**
-     * Mothership mode: sign in through the hosted mothership. The mothership owns identity + the
-     * allowlist, so we send the browser to ITS OAuth and return here flagged for the connect
-     * exchange (`maybeConnectMothership`). No-op if the mothership URL isn't known.
-     */
-    function signInViaMothership() {
-      if (typeof window === 'undefined') return
-      const base = localMode.value?.mothershipUrl
-      if (!base) return
-      mothershipError.value = null
-      const here = new URL(window.location.origin + window.location.pathname)
-      here.searchParams.set('mothership_connect', '1')
-      const redirect = new URLSearchParams({ redirect: here.toString() })
-      window.location.href = `${base.replace(/\/$/, '')}/auth/login?${redirect}`
-    }
+    // The sign-in / sign-out operations and the redirect-fragment handling, split into cohesive
+    // factories sharing the state above (a size-only extraction mirroring `stores/board/` —
+    // behaviour is identical to the former in-closure functions). The redirect factory applies a
+    // mothership-exchanged session through the session factory's setter.
+    const { applySession, ...session } = createAuthSessionActions({
+      api,
+      apiBase,
+      token,
+      user,
+      autoLoginProvider,
+    })
+    const { consumeRedirectToken, maybeConnectMothership, signInViaMothership, maybeAcceptInvite } =
+      createAuthRedirectActions({ api, token, localMode, mothershipError, applySession })
 
     /** Resolve auth state: capture any redirect token, then check the backend. */
     async function bootstrap() {
@@ -237,7 +195,7 @@ export const useAuthStore = defineStore(
         localMode.value.patLogin?.configured.includes(autoLoginProvider.value)
       ) {
         try {
-          await patLogin({ provider: autoLoginProvider.value })
+          await session.patLogin({ provider: autoLoginProvider.value })
         } catch {
           autoLoginProvider.value = null
         }
@@ -248,106 +206,6 @@ export const useAuthStore = defineStore(
       ready.value = true
     }
 
-    /** Redeem an `?invite=` token in the URL for the signed-in user, then clean the URL. */
-    async function maybeAcceptInvite() {
-      if (typeof window === 'undefined') return
-      const params = new URLSearchParams(window.location.search)
-      const inviteToken = params.get('invite')
-      if (!inviteToken) return
-      try {
-        await api.acceptInvite(inviteToken)
-      } catch {
-        // Stale/already-accepted invite — ignore and let the app load normally.
-      }
-      params.delete('invite')
-      const qs = params.toString()
-      history.replaceState(null, '', window.location.pathname + (qs ? `?${qs}` : ''))
-    }
-
-    /** Build a post-login redirect back to the current page, with an optional invite. */
-    function redirectTarget(invite?: string): string {
-      const here = window.location.origin + window.location.pathname
-      const params = new URLSearchParams({ redirect: here })
-      if (invite) params.set('invite', invite)
-      return params.toString()
-    }
-
-    /** Send the browser to the backend's GitHub login, returning here after. */
-    function login(invite?: string) {
-      if (typeof window === 'undefined') return
-      window.location.href = `${apiBase}/auth/login?${redirectTarget(invite)}`
-    }
-
-    /** Send the browser to the backend's Google login, returning here after. */
-    function loginWithGoogle(invite?: string) {
-      if (typeof window === 'undefined') return
-      window.location.href = `${apiBase}/auth/google/login?${redirectTarget(invite)}`
-    }
-
-    /** Apply a freshly-minted token + user (from password signup/login). */
-    function applySession(result: { token: string; user: AuthUser }) {
-      token.value = result.token
-      user.value = result.user
-    }
-
-    /** Register a new email/password user (optionally redeeming an invite). */
-    async function signup(body: {
-      email: string
-      password: string
-      name?: string
-      invite?: string
-    }) {
-      applySession(await api.signup(body))
-    }
-
-    /** Sign in with email/password. */
-    async function passwordLogin(body: { email: string; password: string }) {
-      applySession(await api.passwordLogin(body))
-    }
-
-    /**
-     * Local mode: sign in as the account a source-control PAT belongs to. `token` omitted
-     * uses the server-configured PAT (one-click); otherwise a pasted token. Resolves to the
-     * SAME canonical user as GitHub OAuth would (keyed on the provider's numeric id).
-     */
-    async function patLogin(body: { provider: 'github' | 'gitlab'; token?: string }) {
-      applySession(await api.patLogin(body))
-      // Remember the choice so a later load re-mints the session from the env PAT silently.
-      autoLoginProvider.value = body.provider
-    }
-
-    /** Request a password-reset link by email (always resolves; never reveals existence). */
-    async function forgotPassword(email: string) {
-      await api.forgotPassword({ email })
-    }
-
-    /** Redeem a reset token and set a new password. Throws on an invalid/expired token. */
-    async function resetPassword(token: string, password: string) {
-      await api.resetPassword({ token, password })
-    }
-
-    /** Drop the local session (sessions are stateless server-side). */
-    function logout() {
-      api.logout().catch(() => {})
-      token.value = null
-      user.value = null
-      // Forget the remembered provider so logout sticks (otherwise bootstrap would
-      // immediately re-mint a session from the env PAT).
-      autoLoginProvider.value = null
-    }
-
-    /**
-     * Called by the API client when a request comes back 401. Drops the dead session but KEEPS
-     * the remembered provider (unlike logout): a 401 from an expired/rotated token or a
-     * transient blip should let the next load silently re-mint from the env PAT, not force the
-     * login screen. The guarded re-mint in `bootstrap` clears the choice itself if it genuinely
-     * fails (PAT removed/revoked), so there's no re-login loop.
-     */
-    function handleUnauthorized() {
-      token.value = null
-      user.value = null
-    }
-
     return {
       token,
       user,
@@ -367,16 +225,8 @@ export const useAuthStore = defineStore(
       isMisconfigured,
       needsLogin,
       bootstrap,
-      login,
-      loginWithGoogle,
       signInViaMothership,
-      signup,
-      passwordLogin,
-      patLogin,
-      forgotPassword,
-      resetPassword,
-      logout,
-      handleUnauthorized,
+      ...session,
     }
   },
   { persist: { pick: ['token', 'autoLoginProvider'] } },

package/app/stores/board/mutations.ts

@@ -1,4 +1,3 @@
-import type { UpdateBlockInput } from '@cat-factory/contracts'
 import type {
   BlockType,
   CreateTaskType,
@@ -6,16 +5,16 @@ import type {
   TaskTypeFields,
   Block,
 } from '~/types/domain'
-import { useServicesStore } from '~/stores/services'
 import { useWorkspaceStore } from '~/stores/workspace'
 import type { BoardWriteContext } from './context'
-import { UNDO_WINDOW_MS } from './context'
 
 /**
- * The board's create / move / update / dependency write operations, extracted from the store
- * setup. Each closes over the shared {@link BoardWriteContext} (the authoritative block returned
- * by the API is applied via `upsert`) so behaviour is identical to the original in-closure
- * functions — the split is purely to keep every function within the size budget.
+ * The board's creation writes (services / modules / tasks / epics) plus the archive-restore
+ * lifecycle, extracted from the store setup. Each closes over the shared
+ * {@link BoardWriteContext} (the authoritative block returned by the API is applied via `upsert`)
+ * so behaviour is identical to the original in-closure functions — the split is purely to keep
+ * every function within the size budget. The placement + edit writes live alongside in
+ * {@link createBoardPlacement}.
  */
 export function createBoardMutations(ctx: BoardWriteContext) {
   const { getBlock, upsert, api, toast, tr } = ctx
@@ -152,69 +151,6 @@ export function createBoardMutations(ctx: BoardWriteContext) {
     return block
   }
 
-  /**
-   * Move a block into a new container at a new local position. Drag-reparent commits
-   * silently on a small overshoot, so a successful move (into a *different* container,
-   * not an undo of one) offers a one-click undo back to its previous home.
-   */
-  async function reparentBlock(
-    id: string,
-    newParentId: string,
-    position: { x: number; y: number },
-    opts: { undoable?: boolean } = { undoable: true },
-  ) {
-    const b = getBlock(id)
-    const parent = getBlock(newParentId)
-    if (!b || !parent || b.id === newParentId) return
-    // tasks may live in services or modules; modules only in services
-    if (b.level === 'task' && parent.level !== 'frame' && parent.level !== 'module') return
-    if (b.level === 'module' && parent.level !== 'frame') return
-    // Optimistic: drop the block into the new container immediately so it doesn't
-    // briefly snap back to its old home while the request is in flight. Snapshot
-    // the old home so a rejected reparent restores it rather than leaving the
-    // block in the wrong container (a structural lie that survives until re-hydrate).
-    const prevParentId = b.parentId
-    const prevPosition = b.position
-    const name = b.title
-    b.parentId = newParentId
-    b.position = position
-    try {
-      upsert(
-        await api.reparentBlock(useWorkspaceStore().requireId(), id, {
-          parentId: newParentId,
-          position,
-        }),
-      )
-      // Offer an undo back to the previous container (a drag overshoot is easy). The undo
-      // move is itself non-undoable so the toast doesn't ping-pong.
-      if (opts.undoable && prevParentId) {
-        toast.add({
-          title: tr('board.toast.moved', { name }),
-          icon: 'i-lucide-move',
-          color: 'neutral',
-          duration: UNDO_WINDOW_MS,
-          actions: [
-            {
-              label: tr('common.undo'),
-              icon: 'i-lucide-undo-2',
-              onClick: () =>
-                void reparentBlock(id, prevParentId, prevPosition, { undoable: false }),
-            },
-          ],
-        })
-      }
-    } catch (e) {
-      b.parentId = prevParentId
-      b.position = prevPosition
-      toast.add({
-        title: tr('board.toast.moveFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
-    }
-  }
-
   /**
    * Archive a service (hide it + its subtree, restorable with no expiry) — the non-destructive
    * alternative to deleting a service that still has unfinished tasks. The acting tab isn't
@@ -232,121 +168,6 @@ export function createBoardMutations(ctx: BoardWriteContext) {
     await useWorkspaceStore().refresh()
   }
 
-  /**
-   * Local-only optimistic position update during an active drag — no persistence.
-   * A drag fires this on every pointer move so the block tracks the cursor without
-   * a per-move API round-trip; the final position is committed once via
-   * {@link moveBlock} (or {@link reparentBlock}) on release. Persisting every move
-   * raced: out-of-order responses to the burst of in-flight writes could land a
-   * stale position last, snapping the block back after the user let go.
-   */
-  function previewMove(id: string, position: { x: number; y: number }) {
-    const b = getBlock(id)
-    if (b) b.position = position
-  }
-
-  async function moveBlock(id: string, position: { x: number; y: number }) {
-    const b = getBlock(id)
-    if (!b) return
-    const prevPosition = b.position
-    b.position = position // optimistic: keep the drag feeling instant
-    try {
-      // A mounted service frame's position is a PER-WORKSPACE layout override on the mount, not
-      // on the (shared) block — so route a frame drag there. Other moves write the block.
-      const services = useServicesStore()
-      const mount = services.serviceByFrameBlock[id]
-        ? services.byServiceId[services.serviceByFrameBlock[id]!.id]
-        : undefined
-      if (mount) {
-        await services.updateLayout(mount.serviceId, position)
-        return
-      }
-      upsert(await api.moveBlock(useWorkspaceStore().requireId(), id, { position }))
-    } catch (e) {
-      // Restore the pre-drag position — a rejected move must not leave the block at a
-      // spot the server never stored (a lie that survives until the next re-hydrate).
-      b.position = prevPosition
-      toast.add({
-        title: tr('board.toast.moveFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
-    }
-  }
-
-  /** Patch the user-editable fields of a block (title, features, threshold…). */
-  async function updateBlock(id: string, patch: UpdateBlockInput) {
-    const b = getBlock(id)
-    if (!b) return
-    // Snapshot ONLY the fields this patch touches so a rejected write restores them exactly
-    // (a patch may set several at once) rather than leaving a stale optimistic value stuck on
-    // screen with no feedback — the same rollback contract the other mutations here follow.
-    const prev: Record<string, unknown> = {}
-    const patchRecord = patch as Record<string, unknown>
-    const record = b as unknown as Record<string, unknown>
-    for (const key of Object.keys(patch)) prev[key] = record[key]
-    Object.assign(b, patch) // optimistic
-    try {
-      upsert(await api.updateBlock(useWorkspaceStore().requireId(), id, patch))
-    } catch (e) {
-      // Re-resolve the block: a live event may have replaced its object reference (`upsert`
-      // swaps in a fresh one) while the write was in flight, so `b` can be stale. Only revert
-      // fields that still hold OUR optimistic value, so a newer server value that landed
-      // mid-flight isn't clobbered by the rollback.
-      const cur = getBlock(id) as unknown as Record<string, unknown> | undefined
-      if (cur) {
-        for (const key of Object.keys(patch)) {
-          if (cur[key] === patchRecord[key]) cur[key] = prev[key]
-        }
-      }
-      toast.add({
-        title: tr('board.toast.updateFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
-    }
-  }
-
-  /**
-   * Toggle a dependency edge target -> source (target dependsOn source). The backend
-   * rejects an edge that would close a cycle (422) — surface that as a toast rather than
-   * letting it throw unhandled out of a board gesture.
-   */
-  async function toggleDependency(targetId: string, sourceId: string) {
-    if (targetId === sourceId || !getBlock(targetId)) return
-    try {
-      upsert(await api.toggleDependency(useWorkspaceStore().requireId(), targetId, { sourceId }))
-    } catch (e) {
-      toast.add({
-        title: tr('board.toast.linkFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
-    }
-  }
-
-  /** Remove a dependency edge target -> source if it exists. */
-  async function removeDependency(targetId: string, sourceId: string) {
-    const t = getBlock(targetId)
-    if (!t || !t.dependsOn.includes(sourceId)) return
-    // the backend exposes a single toggle; the edge exists, so toggling removes it
-    try {
-      upsert(await api.toggleDependency(useWorkspaceStore().requireId(), targetId, { sourceId }))
-    } catch (e) {
-      // Mirror `toggleDependency`: a failure must surface (and leave the edge visible) rather
-      // than rejecting unhandled with no feedback.
-      toast.add({
-        title: tr('board.toast.unlinkFailed'),
-        description: e instanceof Error ? e.message : String(e),
-        icon: 'i-lucide-triangle-alert',
-        color: 'error',
-      })
-    }
-  }
-
   return {
     addBlock,
     addServiceFromRepo,
@@ -354,13 +175,7 @@ export function createBoardMutations(ctx: BoardWriteContext) {
     addModule,
     addEpic,
     assignToEpic,
-    reparentBlock,
     archiveService,
     restoreService,
-    previewMove,
-    moveBlock,
-    updateBlock,
-    toggleDependency,
-    removeDependency,
   }
 }