diff --git a/app/web/src/components/FuncEditor/FuncDetails.vue b/app/web/src/components/FuncEditor/FuncDetails.vue
index 8cd6f9e75c..6bfc10ed3a 100644
--- a/app/web/src/components/FuncEditor/FuncDetails.vue
+++ b/app/web/src/components/FuncEditor/FuncDetails.vue
@@ -298,7 +298,6 @@ const funcStore = useFuncStore();
 const assetStore = useAssetStore();
 
 const emit = defineEmits<{
-  (e: "detached"): void;
   (e: "expandPanel"): void;
 }>();
 
@@ -389,7 +388,7 @@ const execFunc = () => {
 const isDetaching = ref(false);
 const detachFunc = async () => {
   if (detachRef.value && "detachFunc" in detachRef.value) {
-    await detachRef.value.detachFunc();
+    const associations = await detachRef.value.detachFunc();
     if (assetStore.selectedAssetId)
       assetStore.LOAD_ASSET(assetStore.selectedAssetId); // reloads the fn list
     if (funcStore.selectedFuncId)
@@ -401,16 +400,14 @@ const detachFunc = async () => {
       );
     funcStore.selectedFuncId = undefined; // brings you back to the asset detail
 
-    /* this code was never reachable
     if (associations && editingFunc.value) {
       isDetaching.value = true;
       await funcStore.UPDATE_FUNC({
         ...editingFunc.value,
         associations,
       });
-      emit("detached");
       isDetaching.value = false;
-    } */
+    }
   }
 };
 
diff --git a/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue b/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue
index 7306147b18..c7a183cf15 100644
--- a/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue
+++ b/app/web/src/components/Workspace/WorkspaceCustomizeAssets.vue
@@ -48,7 +48,6 @@
           :funcId="funcStore.selectedFuncId"
           :schemaVariantId="assetStore.selectedAsset?.defaultSchemaVariantId"
           allowTestPanel
-          @detached="onDetach"
           @expand-panel="rightResizablePanelRef?.maximize()"
         />
         <!-- the key here is to force remounting so we get the proper asset
@@ -185,12 +184,6 @@ onBeforeUnmount(() => {
   window.removeEventListener("keydown", onKeyDown);
 });
 
-const onDetach = async () => {
-  if (assetStore.selectedAssetId && funcStore.selectedFuncId) {
-    assetStore.closeFunc(assetStore.selectedAssetId, funcStore.selectedFuncId);
-  }
-};
-
 watch(
   () => assetStore.selectedAssets.length,
   (newVal, oldVal) => {
diff --git a/lib/dal/src/action/prototype.rs b/lib/dal/src/action/prototype.rs
index 9044934f76..29d3c6ad41 100644
--- a/lib/dal/src/action/prototype.rs
+++ b/lib/dal/src/action/prototype.rs
@@ -10,6 +10,7 @@ use thiserror::Error;
 use veritech_client::{ActionRunResultSuccess, ResourceStatus};
 
 use crate::{
+    action::ActionId,
     component::ComponentUpdatedPayload,
     diagram::{DiagramError, SummaryDiagramComponent},
     func::{
@@ -421,9 +422,43 @@ impl ActionPrototype {
         }
         Ok(triggered_actions)
     }
+
+    async fn find_enqueued_actions(
+        ctx: &DalContext,
+        id: ActionPrototypeId,
+    ) -> ActionPrototypeResult<Vec<ActionId>> {
+        let mut enqueued_actions = vec![];
+
+        for (_, tail_node_idx, _head_node_idx) in ctx
+            .workspace_snapshot()?
+            .edges_directed_for_edge_weight_kind(id, Incoming, EdgeWeightKindDiscriminants::Use)
+            .await?
+        {
+            if let NodeWeight::Action(node_weight) = ctx
+                .workspace_snapshot()?
+                .get_node_weight(tail_node_idx)
+                .await?
+            {
+                enqueued_actions.push(node_weight.id().into());
+            }
+        }
+        Ok(enqueued_actions)
+    }
+
     pub async fn remove(ctx: &DalContext, id: ActionPrototypeId) -> ActionPrototypeResult<()> {
         let change_set = ctx.change_set()?;
-
+        // check if there are existing actions queued for this prototype and remove them
+        let enqueued_actions = dbg!(Self::find_enqueued_actions(ctx, id).await?);
+
+        for action in enqueued_actions {
+            ctx.workspace_snapshot()?
+                .remove_node_by_id(change_set, action)
+                .await?;
+            WsEvent::action_list_updated(ctx)
+                .await?
+                .publish_on_commit(ctx)
+                .await?;
+        }
         ctx.workspace_snapshot()?
             .remove_node_by_id(change_set, id)
             .await?;
diff --git a/lib/dal/src/func/authoring.rs b/lib/dal/src/func/authoring.rs
index a6cabedeea..8550c7768c 100644
--- a/lib/dal/src/func/authoring.rs
+++ b/lib/dal/src/func/authoring.rs
@@ -46,7 +46,7 @@ use std::sync::Arc;
 use telemetry::prelude::*;
 use thiserror::Error;
 
-use crate::action::prototype::{ActionKind, ActionPrototypeError};
+use crate::action::prototype::{ActionKind, ActionPrototype, ActionPrototypeError};
 use crate::attribute::prototype::argument::{
     AttributePrototypeArgument, AttributePrototypeArgumentError,
 };
@@ -59,9 +59,10 @@ use crate::func::FuncKind;
 use crate::prop::PropError;
 use crate::socket::output::OutputSocketError;
 use crate::{
-    AttributePrototypeId, ComponentError, ComponentId, DalContext, Func, FuncBackendKind,
-    FuncBackendResponseType, FuncError, FuncId, OutputSocketId, PropId, SchemaVariantError,
-    SchemaVariantId, TransactionsError, WorkspaceSnapshotError, WsEventError,
+    AttributePrototype, AttributePrototypeId, ComponentError, ComponentId, DalContext, Func,
+    FuncBackendKind, FuncBackendResponseType, FuncError, FuncId, OutputSocketId, PropId,
+    SchemaVariant, SchemaVariantError, SchemaVariantId, TransactionsError, WorkspaceSnapshotError,
+    WsEventError,
 };
 
 use super::runner::{FuncRunner, FuncRunnerError};
@@ -438,6 +439,33 @@ impl FuncAuthoringClient {
         Ok(())
     }
 
+    /// For a given [`FuncId`], regardless of what kind of [`Func`] it is, look for all associated bindings and remove
+    /// them from every currently attached [`SchemaVariant`]
+    pub async fn detach_func_from_everywhere(
+        ctx: &DalContext,
+        func_id: FuncId,
+    ) -> FuncAuthoringResult<()> {
+        // first check for attribute prototypes
+        let maybe_attribute_prototypes =
+            AttributePrototype::list_ids_for_func_id(ctx, func_id).await?;
+        for attribute_prototype in maybe_attribute_prototypes {
+            save::reset_attribute_prototype(ctx, attribute_prototype, true).await?;
+        }
+
+        // then check for and remove authentication prototypes
+        for schema_variant_id in
+            SchemaVariant::list_schema_variant_ids_using_auth_func_id(ctx, func_id).await?
+        {
+            SchemaVariant::remove_authentication_prototype(ctx, func_id, schema_variant_id).await?;
+        }
+
+        // then check for and remove action prototypes
+        for action_prototype_id in ActionPrototype::list_for_func_id(ctx, func_id).await? {
+            ActionPrototype::remove(ctx, action_prototype_id).await?;
+        }
+        Ok(())
+    }
+
     /// Compiles types corresponding to "lang-js".
     pub fn compile_langjs_types() -> &'static str {
         ts_types::compile_langjs_types()
diff --git a/lib/dal/tests/integration_test/func/authoring/save_func/detach.rs b/lib/dal/tests/integration_test/func/authoring/save_func/detach.rs
index 2da5e0bc47..86c672dc21 100644
--- a/lib/dal/tests/integration_test/func/authoring/save_func/detach.rs
+++ b/lib/dal/tests/integration_test/func/authoring/save_func/detach.rs
@@ -1,9 +1,11 @@
+use dal::action::prototype::{ActionKind, ActionPrototype};
+use dal::action::{Action, ActionId};
 use dal::func::authoring::FuncAuthoringClient;
 use dal::func::summary::FuncSummary;
 use dal::func::view::FuncView;
-use dal::func::AttributePrototypeBag;
+use dal::func::{AttributePrototypeBag, FuncAssociations};
 use dal::{DalContext, Func, Schema, SchemaVariant};
-use dal_test::helpers::ChangeSetTestHelpers;
+use dal_test::helpers::{create_component_for_schema_name, ChangeSetTestHelpers};
 use dal_test::test;
 
 #[test]
@@ -61,3 +63,223 @@ async fn detach_attribute_func(ctx: &mut DalContext) {
     );
     assert!(!funcs.iter().any(|summary| summary.id == func_id));
 }
+
+#[test]
+async fn detach_attach_then_delete_action_func_while_enqueued(ctx: &mut DalContext) {
+    pub async fn can_assemble(ctx: &DalContext, action_id: ActionId) -> bool {
+        let action = Action::get_by_id(ctx, action_id)
+            .await
+            .expect("unable to get action");
+        let prototype_id = Action::prototype_id(ctx, action_id)
+            .await
+            .expect("unable to get prototype id");
+        let _prototype = ActionPrototype::get_by_id(ctx, prototype_id)
+            .await
+            .expect("unable to get prototype");
+        let _func_run_id = ctx
+            .layer_db()
+            .func_run()
+            .get_last_run_for_action_id(ctx.events_tenancy().workspace_pk, action.id().into())
+            .await
+            .expect("unable to get func run id")
+            .map(|f| f.id());
+        let _component_id = Action::component_id(ctx, action_id)
+            .await
+            .expect("unable to get component id");
+        let _my_dependencies = action
+            .get_all_dependencies(ctx)
+            .await
+            .expect("unable to get dependencies");
+        let _dependent_on = Action::get_dependent_actions_by_id(ctx, action_id)
+            .await
+            .expect("unable to get dependent actions");
+        let _hold_status_influenced_by = action
+            .get_hold_status_influenced_by(ctx)
+            .await
+            .expect("unable to get hold status");
+        true
+    }
+    let schema = Schema::find_by_name(ctx, "starfield")
+        .await
+        .expect("unable to find by name")
+        .expect("no schema found");
+    let schema_variant_id = SchemaVariant::get_default_id_for_schema(ctx, schema.id())
+        .await
+        .expect("unable to get default schema variant");
+
+    // Cache the total number of funcs before continuing.
+    let funcs = FuncSummary::list_for_schema_variant_id(ctx, schema_variant_id)
+        .await
+        .expect("unable to get the funcs for a schema variant");
+    let initial_total_funcs = funcs.len();
+
+    // create a component
+    let new_component = create_component_for_schema_name(ctx, "starfield", "component")
+        .await
+        .expect("unable to create new component");
+
+    // check that the action func has been enqueued
+    let enqueued_actions = Action::list_topologically(ctx)
+        .await
+        .expect("can list actions");
+    // create action views
+
+    let mut queued = Vec::new();
+
+    for action_id in enqueued_actions.into_iter() {
+        if can_assemble(ctx, action_id).await {
+            queued.push(action_id);
+        }
+    }
+    // make sure there is one enqueued action
+    assert_eq!(
+        1,            //expected
+        queued.len()  // actual
+    );
+    let func_id = Func::find_id_by_name(ctx, "test:createActionStarfield")
+        .await
+        .expect("unable to find the func")
+        .expect("no func found");
+    let func = Func::get_by_id(ctx, func_id)
+        .await
+        .expect("unable to get func")
+        .expect("func is some");
+
+    // detach the action
+    for action_prototype_id in ActionPrototype::list_for_func_id(ctx, func_id)
+        .await
+        .expect("unable to list prototypes for func")
+    {
+        ActionPrototype::remove(ctx, action_prototype_id)
+            .await
+            .expect("unable to remove action prototype");
+    }
+
+    // check the func count for the schema variant is accurate
+    let funcs = FuncSummary::list_for_schema_variant_id(ctx, schema_variant_id)
+        .await
+        .expect("unable to get the funcs for a schema variant");
+    assert_eq!(
+        initial_total_funcs - 1, // expected
+        funcs.len()              // actual
+    );
+
+    // check that the action has been removed from the queue
+    let enqueued_actions = Action::list_topologically(ctx)
+        .await
+        .expect("can list actions");
+    let mut queued = Vec::new();
+
+    for action_id in enqueued_actions.into_iter() {
+        if can_assemble(ctx, action_id).await {
+            queued.push(action_id);
+        }
+    }
+    // make sure there aren't any enqueued actions
+    assert_eq!(
+        0,            //expected
+        queued.len()  // actual
+    );
+
+    // reattach the create action, and enqueue it. All should work again
+    let action_association = FuncAssociations::Action {
+        kind: ActionKind::Create,
+        schema_variant_ids: vec![schema_variant_id],
+    };
+    FuncAuthoringClient::save_func(
+        ctx,
+        func_id,
+        Some(schema.name),
+        func.name,
+        func.description,
+        func.code_base64,
+        Some(action_association),
+    )
+    .await
+    .expect("unable to save func");
+
+    // ensure it got reattached
+    let funcs = FuncSummary::list_for_schema_variant_id(ctx, schema_variant_id)
+        .await
+        .expect("unable to get the funcs for a schema variant");
+    let total_funcs = funcs.len();
+
+    assert_eq!(
+        initial_total_funcs, // expected
+        total_funcs,         // actual
+    );
+
+    // manually enqueue the action
+    let mut action = None;
+    for prototype in ActionPrototype::for_variant(ctx, schema_variant_id)
+        .await
+        .expect("unable to list prototypes for variant")
+    {
+        if prototype.kind == ActionKind::Create {
+            action = Some(
+                Action::new(ctx, prototype.id, Some(new_component.id()))
+                    .await
+                    .expect("unable to upsert action"),
+            );
+            break;
+        }
+    }
+    // ensure we enqueued the action
+    assert!(action.is_some());
+
+    let enqueued_actions = Action::list_topologically(ctx)
+        .await
+        .expect("can list actions");
+    let mut queued = Vec::new();
+
+    for action_id in enqueued_actions.into_iter() {
+        if can_assemble(ctx, action_id).await {
+            queued.push(action_id);
+        }
+    }
+    assert_eq!(
+        1,            //expected
+        queued.len()  // actual
+    );
+
+    // finally, delete the action
+    let func_id = Func::find_id_by_name(ctx, "test:createActionStarfield")
+        .await
+        .expect("unable to find the func")
+        .expect("no func found");
+    // sdf calls this first if there are associations, so call it here too
+    FuncAuthoringClient::detach_func_from_everywhere(ctx, func_id)
+        .await
+        .expect("could not detach func");
+    Func::delete_by_id(ctx, func_id)
+        .await
+        .expect("unable to delete the func");
+
+    // check the func count for the schema variant
+    let funcs = FuncSummary::list_for_schema_variant_id(ctx, schema_variant_id)
+        .await
+        .expect("unable to get the funcs for a schema variant");
+    assert_eq!(
+        total_funcs - 1, // expected
+        funcs.len()      // actual
+    );
+
+    // check that the action has been removed from the queue
+    let enqueued_actions = Action::list_topologically(ctx)
+        .await
+        .expect("can list actions");
+    let mut queued = Vec::new();
+
+    for action_id in enqueued_actions.into_iter() {
+        if can_assemble(ctx, action_id).await {
+            queued.push(action_id);
+        }
+    }
+    // make sure there aren't any enqueued actions
+    assert_eq!(
+        0,            //expected
+        queued.len()  // actual
+    );
+
+    // let's create the func again
+}
diff --git a/lib/sdf-server/src/server/service/func/delete_func.rs b/lib/sdf-server/src/server/service/func/delete_func.rs
index 6212821128..fb99e38714 100644
--- a/lib/sdf-server/src/server/service/func/delete_func.rs
+++ b/lib/sdf-server/src/server/service/func/delete_func.rs
@@ -1,5 +1,6 @@
 use axum::extract::OriginalUri;
 use axum::{response::IntoResponse, Json};
+use dal::func::authoring::FuncAuthoringClient;
 use dal::{ChangeSet, Func, FuncId, Visibility, WsEvent};
 use serde::{Deserialize, Serialize};
 
@@ -31,7 +32,9 @@ pub async fn delete_func(
     let mut ctx = builder.build(request_ctx.build(request.visibility)).await?;
 
     let force_change_set_id = ChangeSet::force_new(&mut ctx).await?;
-
+    // first remove all existing associations
+    FuncAuthoringClient::detach_func_from_everywhere(&ctx, request.id).await?;
+    // then delete func
     let func_name = Func::delete_by_id(&ctx, request.id).await?;
 
     track(